className: FTaskEventBase

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

code: class FTaskEventBase : public [UE::Tasks::Private::FTaskBase](API\Runtime\Core\Tasks\FTaskBase)


description:
Waits for task's completion for at least the specified amount of time, while executing other tasks. the call can return much later than the given timeout
true if the task is completed

module: Core

code: bool BusyWait ( [FTimespan](API\Runtime\Core\Misc\FTimespan) Timeout ) const


description:
Waits for task's completion or the given condition becomes true, while executing other tasks. the call can return much later than the given condition became true
true if the task is completed

code: template<typename ConditionType> bool BusyWait ( ConditionType && Condition ) const


className: FTaskHandleId

code: typedef void FTaskHandleId


description: Checks if task's execution is done

code: bool IsCompleted() const


description:
Launches a task for asynchronous execution
a trivially relocatable instance that can be used to wait for task completion or to obtain task execution result

code: template<typename TaskBodyType> void Launch ( const TCHAR * DebugName, TaskBodyType && TaskBody, ETaskPriority Priority, [EExtendedTaskPriority](API\Runtime\Core\Tasks\UE__Tasks__EExtendedTaskPriority) ExtendedPriority )


description:
Launches a task for asynchronous execution, with prerequisites that must be completed before the task is scheduled
a trivially relocatable instance that can be used to wait for task completion or to obtain task execution result

code: template<typename TaskBodyType, typename PrerequisitesCollectionType> void Launch ( const TCHAR * DebugName, TaskBodyType && TaskBody, PrerequisitesCollectionType && Prerequisites, ETaskPriority Priority, [EExtendedTaskPriority](API\Runtime\Core\Tasks\UE__Tasks__EExtendedTaskPriority) ExtendedPriority )


code: bool operator== ( const [FTaskHandle](API\Runtime\Core\Tasks\FTaskHandle) & Other ) const


code: bool operator!= ( const [FTaskHandle](API\Runtime\Core\Tasks\FTaskHandle) & Other ) const


description:
Waits for task's completion with timeout. Tries to retract the task and execute it in-place, if failed - blocks until the task is completed by another thread. If timeout is zero, tries to retract the task and returns immedially after that.
true if the task is completed

code: bool Wait ( [FTimespan](API\Runtime\Core\Misc\FTimespan) Timeout ) const


code: FTaskHandle ( [FTaskBase](API\Runtime\Core\Tasks\FTaskBase) * Other )


className: FTaskHandle

code: class FTaskHandle

Pimpl

type: TRefCountPtr<F...


code: ETaskPriority GetTaskPriority() const


code: FTaskPriorityCVar ( const TCHAR * Name, const TCHAR * Help, ETaskPriority DefaultPriority, [EExtendedTaskPriority](API\Runtime\Core\Tasks\UE__Tasks__EExtendedTaskPriority) DefaultExtendedPriority )


className: FTaskPriorityCVar

description: Console variable for configuring task priorities Example:FTaskPriorityCVarCVar{ TEXT("CVarName"), TEXT("CVarHelp"), ETaskPriority::Normal,EExtendedTaskPriority::None}; Launch(UE_SOURCE_LOCATION, [] {},CVar.GetTaskPriority(), CVar.GetExtendedTaskPriority()).Wait();

code: class FTaskPriorityCVar


description: A helper that deduces the template argument

code: static [TExecutableTask](API\Runtime\Core\Tasks\TExecutableTask) * Create ( const TCHAR * InDebugName, TaskBodyType && TaskBody, ETaskPriority InPriority, [EExtendedTaskPriority](API\Runtime\Core\Tasks\UE__Tasks__EExtendedTaskPriority) InExtendedPriority )


className: TExecutableTask::operator delete

code: static void operator delete ( void * Ptr, size_t Size )


className: TExecutableTask::operator new

code: static void * operator new ( size_t Size )


code: TExecutableTask ( const TCHAR * InDebugName, TaskBodyType && TaskBody, ETaskPriority InPriority, [EExtendedTaskPriority](API\Runtime\Core\Tasks\UE__Tasks__EExtendedTaskPriority) InExtendedPriority )


className: TExecutableTask

description: A separate derived class to add "small task" allocation optimization to both base class specializations

code: template<typename TaskBodyType> class TExecutableTask : public [UE::Tasks::Private::TExecutableTaskBase< TaskBodyType >](API\Runtime\Core\Tasks\TExecutableTaskBase)


code: TExecutableTaskBase &40; TExecutableTaskBase && &41;


code: TExecutableTaskBase &40; const TExecutableTaskBase & &41;


className: TExecutableTaskBase

description: FTaskHandle.

code: template<typename TaskBodyType, typename ResultType, typename Enable> class TExecutableTaskBase : public [UE::Tasks::Private::TTaskWithResult< ResultType >](API\Runtime\Core\Tasks\TTaskWithResult)


description: Waits until the task is completed and returns task's result

code: ResultType & GetResult()


description: Private constructor, valid instances can be created only by launching (see friends)

code: TTask &40; Private::FTaskBase &42; Other &41;


className: TTask

description: TTask< void >

code: template<typename ResultType> class TTask : public [UE::Tasks::Private::FTaskHandle](API\Runtime\Core\Tasks\FTaskHandle)


code: TTaskWithResult ( const TCHAR * InDebugName, ETaskPriority InPriority, [EExtendedTaskPriority](API\Runtime\Core\Tasks\UE__Tasks__EExtendedTaskPriority) InExtendedPriority, uint32 InitRefCount )


className: TTaskWithResult

description: An extension ofFTaskBasefor tasks that return a result. Stores task execution result and provides an access to it.

code: template<typename ResultType> class TTaskWithResult : public [UE::Tasks::Private::FTaskBase](API\Runtime\Core\Tasks\FTaskBase)

ResultStorage

type: TTypeCompatible...


description: 2 init refs: one for the initial reference (we don't increment it on passing to `TRefCountPtr_), and one for the internal reference that keeps the task alive while it's in the system. is released either on task completion or by the scheduler after trying to execute the task

code: TExecutableTaskBase ( const TCHAR * InDebugName, TaskBodyType && TaskBody, ETaskPriority InPriority, [EExtendedTaskPriority](API\Runtime\Core\Tasks\UE__Tasks__EExtendedTaskPriority) InExtendedPriority )


className: TTask< void >::GetResult

code: void GetResult&40;&41;


className: TTask< void >::TTask


className: TTask< void >

code: template<> class TTask< void > : public [UE::Tasks::Private::FTaskHandle](API\Runtime\Core\Tasks\FTaskHandle)


description: Adds the nested task to the task that is being currently executed by the current thread. A parent task is not flagged completed until all nested tasks are completed. It's similar to explicitly waiting for a sub-task at the end of its parent task, except explicit waiting blocks the worker executing the parent task until the sub-task is completed. With nested tasks, the worker won't be blocked.

code: namespace UE { namespace Tasks { template<typename TaskType> void UE::Tasks::AddNested ( const TaskType & Nested ) } }


description: Wait for multiple tasks while executing other tasks

code: namespace UE { namespace Tasks { template<typename TaskCollectionType> bool UE::Tasks::BusyWait ( const TaskCollectionType & Tasks, [FTimespan](API\Runtime\Core\Misc\FTimespan) InTimeout ) } }


description: Special task priorities for tasks that are never sent to the scheduler

code: namespace UE { namespace Tasks { enum EExtendedTaskPriority { None, Inline, TaskEvent, Count, } } }


code: namespace UE { namespace Tasks { template<typename TaskBodyType> [TTask](API\Runtime\Core\Tasks\TTask)< TInvokeResult_T< TaskBodyType > > UE::Tasks::Launch ( const TCHAR * DebugName, TaskBodyType && TaskBody, ETaskPriority Priority, [EExtendedTaskPriority](API\Runtime\Core\Tasks\UE__Tasks__EExtendedTaskPriority) ExtendedPriority ) } }


code: namespace UE { namespace Tasks { template<typename TaskBodyType, typename PrerequisitesCollectionType> [TTask](API\Runtime\Core\Tasks\TTask)< TInvokeResult_T< TaskBodyType > > UE::Tasks::Launch ( const TCHAR * DebugName, TaskBodyType && TaskBody, PrerequisitesCollectionType && Prerequisites, ETaskPriority Priority, [EExtendedTaskPriority](API\Runtime\Core\Tasks\UE__Tasks__EExtendedTaskPriority) ExtendedPriority ) } }


description: Creates and returns an already completed task holding a result value constructed from given args

code: namespace UE { namespace Tasks { template<typename ResultType, typename... ArgTypes> [TTask](API\Runtime\Core\Tasks\TTask)< ResultType > UE::Tasks::MakeCompletedTask ( ArgTypes &&... Args ) } }


code: namespace UE { namespace Tasks { template<typename... TaskTypes> [TStaticArray](API\Runtime\Core\Containers\TStaticArray)< [Private::FTaskBase](API\Runtime\Core\Tasks\FTaskBase) *, sizeof...(TaskTypes)> UE::Tasks::Prerequisites ( TaskTypes &... Tasks ) } }


code: namespace UE { namespace Tasks { template<typename TaskCollectionType> const TaskCollectionType & UE::Tasks::Prerequisites ( const TaskCollectionType & Tasks ) } }


code: namespace UE { namespace Tasks { namespace Private { template<int32 Index, typename ArrayType, typename TaskType> void UE::Tasks::Private::PrerequisitesUnpacker ( ArrayType & Array, TaskType & Task ) } } }


code: namespace UE { namespace Tasks { namespace Private { template<int32 Index, typename ArrayType, typename FirstTaskType, typename... OtherTasksTypes> void UE::Tasks::Private::PrerequisitesUnpacker ( ArrayType & Array, FirstTaskType & FirstTask, OtherTasksTypes &... OtherTasks ) } } }


description: Task retraction of multiple tasks, with timeout. The timeout is rounded up to any successful task execution, which means that it can time out only in-between individual task retractions. WARNING: the function can returntrue_ even if some tasks are still not completed. Thetrue_ means only that the tasks are executed and have no other pending dependencies, but can be still in the process of completion (concurrently). The caller still needs to wait for completion.

code: namespace UE { namespace Tasks { namespace Private { template<typename TaskCollectionType> bool UE::Tasks::Private::TryRetractAndExecute ( const TaskCollectionType & Tasks, [FTimeout](API\Runtime\Core\Misc\FTimeout) Timeout ) } } }


code: namespace UE { namespace Tasks { void UE::Tasks::Wait ( [Private::FTaskHandle](API\Runtime\Core\Tasks\FTaskHandle) & Task ) } }


code: namespace UE { namespace Tasks { namespace Private { template<typename TaskCollectionType> [TArray](API\Runtime\Core\Containers\TArray)< [TaskTrace::FId](API\Runtime\Core\Async\FId) > UE::Tasks::Private::GetTraceIds ( const TaskCollectionType & Tasks ) } } }


description: Wait for multiple tasks, with timeout

code: namespace UE { namespace Tasks { template<typename TaskCollectionType> bool UE::Tasks::Wait ( const TaskCollectionType & Tasks, [FTimespan](API\Runtime\Core\Misc\FTimespan) InTimeout ) } }


code: void operator() ( Type * Object ) const


className: DefaultDeleter

description: Deletes an object via the standard delete operator

code: template<typename Type> struct DefaultDeleter


className: FCopyFunc

code: typedef void *(*)(void *) FCopyFunc


className: FDeleteFunc

code: typedef void(*)(void *) FDeleteFunc


code: template<typename TupleType> static bool Compare ( const TupleType & Lhs, const TupleType & Rhs )


className: FEqualityHelper

description: FEqualityHelper< ArgCount, ArgCount >

code: template<uint32 ArgCount, uint32 ArgToCompare> struct FEqualityHelper


className: FEqualityHelper< ArgCount, ArgCount >::Compare

code: template<typename TupleType> static bool Compare &40; const TupleType & Lhs, const TupleType & Rhs &41;


className: FEqualityHelper< ArgCount, ArgCount >

code: template<uint32 ArgCount> struct FEqualityHelper< ArgCount, ArgCount >


description:
Calculate GCD.
Greatest common divisor of A and B.

code: static int32 GCD ( int32 A, int32 B )


className: FEuclidDivisionGCD

description: Euclidean algorithm using modulo policy.

code: class FEuclidDivisionGCD


className: bCanBeNull

code: static constexpr bool bCanBeNull = false;


code: template<typename FunctorType> [TRemoveReference](API\Runtime\Core\Templates\TRemoveReference)< FunctorType >::Type * Bind ( FunctorType && InFunc )


code: void * BindCopy ( const [FFunctionRefStoragePolicy](API\Runtime\Core\Templates\FFunctionRefStoragePolicy) & Other )


description: Returns a pointer to the callable object - needed byTFunctionRefBase.

code: void * GetPtr() const


description: Destroy any owned bindings - called byTFunctionRefBaseonly ifBind()orBindCopy()was called.

code: void Unbind() const


className: FFunctionRefStoragePolicy

code: struct FFunctionRefStoragePolicy


code: static constexpr bool bCanBeNull = true;


code: void * BindCopy ( const [FFunctionStorage](API\Runtime\Core\Templates\FFunctionStorage) & Other )


code: [IFunction_OwnedObject](API\Runtime\Core\Templates\IFunction_OwnedObject) * GetBoundObject() const


code: [FFunctionStorage](API\Runtime\Core\Templates\FFunctionStorage) & operator= ( [FFunctionStorage](API\Runtime\Core\Templates\FFunctionStorage) && Other )


code: [FFunctionStorage](API\Runtime\Core\Templates\FFunctionStorage) & operator= ( const [FFunctionStorage](API\Runtime\Core\Templates\FFunctionStorage) & Other )


description: Destroy any owned bindings - called byTFunctionRefBaseonly if Bind() orBindCopy()was called.

code: void Unbind()


code: FFunctionStorage ( [FFunctionStorage](API\Runtime\Core\Templates\FFunctionStorage) && Other )


code: FFunctionStorage ( const [FFunctionStorage](API\Runtime\Core\Templates\FFunctionStorage) & Other )


className: FFunctionStorage

code: struct FFunctionStorage

HeapAllocation

type: void *

InlineAllocation

type: TAlignedBytes< ...

description: Inline storage for an owned object.


className: FIdentityFunctor

description: A functor which returns whatever is passed to it. Mainly used for generic composition.

code: struct FIdentityFunctor


code: template<typename T> T && operator() ( T && Val ) const


className: FMakeReferenceTo

code: template<class T> struct FMakeReferenceTo


className: FMakeReferenceTo< const void >

code: template<> struct FMakeReferenceTo< const void >


className: FMakeReferenceTo< void >

description: Specialization forFMakeReferenceTo.

code: template<> struct FMakeReferenceTo< void >


description: Ensure the class cannot be constructed directly

code: FNoncopyable()


code: FNoncopyable &40; const FNoncopyable & &41;


description: The class should not be used polymorphically

code: ~FNoncopyable()


className: FNoncopyable

description: Utility template for a class that should not be copyable. Derive from this class to make your class non-copyable

code: class FNoncopyable


className: FNoopStruct

description: Used to avoid cluttering code with ifdefs.

code: struct FNoopStruct


className: FNullTag

description: NOTE: The following is an Unreal extension to standard shared_ptr behavior.

code: struct FNullTag


code: uint32 operator() ( float Value ) const


className: FRadixSortKeyFloat

description: Float cast to uint32 which maintains sorted orderhttp://codercorner.com/RadixSortRevisited.htm

code: struct FRadixSortKeyFloat


code: namespace Freeze { template<typename KeyType, typename ValueType> uint32 Freeze::IntrinsicAppendHash ( const [TTuple](API\Runtime\Core\Misc\TTuple)< KeyType, ValueType > * DummyObject, const [FTypeLayoutDesc](API\Runtime\Core\Serialization\FTypeLayoutDesc) & TypeDesc, const [FPlatformTypeLayoutParameters](API\Runtime\Core\Serialization\FPlatformTypeLayoutParameters) & LayoutParams, [FSHA1](API\Runtime\Core\Misc\FSHA1) & Hasher ) }


code: namespace Freeze { template<typename KeyType, typename ValueType> uint32 Freeze::IntrinsicGetTargetAlignment ( const [TTuple](API\Runtime\Core\Misc\TTuple)< KeyType, ValueType > * DummyObject, const [FTypeLayoutDesc](API\Runtime\Core\Serialization\FTypeLayoutDesc) & TypeDesc, const [FPlatformTypeLayoutParameters](API\Runtime\Core\Serialization\FPlatformTypeLayoutParameters) & LayoutParams ) }


code: namespace Freeze { template<typename KeyType, typename ValueType> uint32 Freeze::IntrinsicUnfrozenCopy ( const [FMemoryUnfreezeContent](API\Runtime\Core\Serialization\FMemoryUnfreezeContent) & Context, const [TTuple](API\Runtime\Core\Misc\TTuple)< KeyType, ValueType > & Object, void * OutDst ) }


code: namespace Freeze { template<class ObjectType, ESPMode Mode> void Freeze::IntrinsicWriteMemoryImage ( [FMemoryImageWriter](API\Runtime\Core\Serialization\FMemoryImageWriter) & Writer, const [TSharedPtr](API\Runtime\Core\Templates\TSharedPtr)< ObjectType, Mode > & Object, const [FTypeLayoutDesc](API\Runtime\Core\Serialization\FTypeLayoutDesc) & ) }


code: namespace Freeze { template<typename KeyType, typename ValueType> void Freeze::IntrinsicWriteMemoryImage ( [FMemoryImageWriter](API\Runtime\Core\Serialization\FMemoryImageWriter) & Writer, const [TTuple](API\Runtime\Core\Misc\TTuple)< KeyType, ValueType > & Object, const [FTypeLayoutDesc](API\Runtime\Core\Serialization\FTypeLayoutDesc) & ) }


code: [FRefCountBase](API\Runtime\Core\Templates\FRefCountBase) & operator= ( const [FRefCountBase](API\Runtime\Core\Templates\FRefCountBase) & Rhs )


code: FRefCountBase ( const [FRefCountBase](API\Runtime\Core\Templates\FRefCountBase) & Rhs )


className: FRefCountBase

description: Base class implementing thread-safe reference counting.

code: class FRefCountBase


code: FRefCountedObject ( const [FRefCountedObject](API\Runtime\Core\Templates\FRefCountedObject) & Rhs )


className: FRefCountedObject

description: This class should not be used for new code as it does not use atomic operations to update the reference count.

code: class FRefCountedObject


description:
Returns the number of shared references to this object (including this reference.)
Number of shared references to the object (including this reference.)

code: const int32 GetSharedReferenceCount() const


code: [FRefCountedObject](API\Runtime\Core\Templates\FRefCountedObject) & operator= ( const [FRefCountedObject](API\Runtime\Core\Templates\FRefCountedObject) & Rhs )


description:
Returns true if this is the only shared reference to this object. Note that there may be outstanding weak references left.
True if there is only one shared reference to the object, and this is it!

code: const bool IsUnique() const


description:
Tests to see whether or not this shared counter contains a valid reference
True if reference is valid

code: const bool IsValid() const


description: Assignment operator adds a reference to the assigned object. If this counter was previously referencing an object, that reference will be released.

code: [FSharedReferencer](API\Runtime\Core\Templates\FSharedReferencer) & operator= ( [FSharedReferencer](API\Runtime\Core\Templates\FSharedReferencer) const & InSharedReference )


description: Move assignment operator adds no references to the assigned object. If this counter was previously referencing an object, that reference will be released.

code: [FSharedReferencer](API\Runtime\Core\Templates\FSharedReferencer) & operator= ( [FSharedReferencer](API\Runtime\Core\Templates\FSharedReferencer) && InSharedReference )


description: Constructor that counts a single reference to the specified object

code: FSharedReferencer ( [TReferenceControllerBase](API\Runtime\Core\Templates\TReferenceControllerBase)< Mode > * InReferenceController )


description: Move constructor creates no new references

code: FSharedReferencer ( [FSharedReferencer](API\Runtime\Core\Templates\FSharedReferencer) && InSharedReference )


description: Creates a shared referencer object from a weak referencer object. This will only result in a valid object reference if the object already has at least one other shared referencer.

code: FSharedReferencer ( [FWeakReferencer](API\Runtime\Core\Templates\FWeakReferencer)< Mode > const & InWeakReference )


code: FSharedReferencer ( [FWeakReferencer](API\Runtime\Core\Templates\FWeakReferencer)< Mode > && InWeakReference )


className: FSharedReferencer

description: FSharedReferenceris a wrapper around a pointer to a reference controller that is used by either aTSharedRefor aTSharedPtrto keep track of a referenced object's lifetime

code: template<ESPMode Mode> class FSharedReferencer


description: Constructor for an empty shared referencer object

code: FSharedReferencer()


className: FStaticCastTag

description: Dummy structures used internally as template arguments for typecasts

code: struct FStaticCastTag


description: Destructor.

code: ~FSharedReferencer()


description: Copy constructor creates a new reference to the existing object

code: FSharedReferencer ( [FSharedReferencer](API\Runtime\Core\Templates\FSharedReferencer) const & InSharedReference )


code: [FThreadSafeRefCountedObject](API\Runtime\Core\Templates\FThreadSafeRefCountedObject) & operator= ( const [FThreadSafeRefCountedObject](API\Runtime\Core\Templates\FThreadSafeRefCountedObject) & Rhs )


code: FThreadSafeRefCountedObject ( const [FThreadSafeRefCountedObject](API\Runtime\Core\Templates\FThreadSafeRefCountedObject) & Rhs )


code: virtual ~FThreadSafeRefCountedObject()


className: FThreadSafeRefCountedObject

description: LikeFRefCountedObject, but internal ref count is thread safe

code: class FThreadSafeRefCountedObject


className: FVirtualDestructor

code: struct FVirtualDestructor


description:
Tests to see whether or not this weak counter contains a valid reference
True if reference is valid

code: const bool IsValid() const


description: Assignment operator from a weak referencer object. If this counter was previously referencing an object, that reference will be released.

code: [FWeakReferencer](API\Runtime\Core\Templates\FWeakReferencer) & operator= ( [FWeakReferencer](API\Runtime\Core\Templates\FWeakReferencer) const & InWeakReference )


description: Assignment operator from an rvalue weak referencer object. If this counter was previously referencing an object, that reference will be released.

code: [FWeakReferencer](API\Runtime\Core\Templates\FWeakReferencer) & operator= ( [FWeakReferencer](API\Runtime\Core\Templates\FWeakReferencer) && InWeakReference )


description: Assignment operator from a shared reference counter. If this counter was previously referencing an object, that reference will be released.

code: [FWeakReferencer](API\Runtime\Core\Templates\FWeakReferencer) & operator= ( [FSharedReferencer](API\Runtime\Core\Templates\FSharedReferencer)< Mode > const & InSharedReference )


description: Default constructor with empty counter

code: FWeakReferencer()


description: Construct a weak referencer object from another weak referencer

code: FWeakReferencer ( [FWeakReferencer](API\Runtime\Core\Templates\FWeakReferencer) const & InWeakRefCountPointer )


description: Construct a weak referencer object from an rvalue weak referencer

code: FWeakReferencer ( [FWeakReferencer](API\Runtime\Core\Templates\FWeakReferencer) && InWeakRefCountPointer )


description: Construct a weak referencer object from a shared referencer object

code: FWeakReferencer ( [FSharedReferencer](API\Runtime\Core\Templates\FSharedReferencer)< Mode > const & InSharedRefCountPointer )


description: Destructor.

code: ~FWeakReferencer()


className: FWeakReferencer

description: FWeakReferenceris a wrapper around a pointer to a reference controller that is used by aTWeakPtrto keep track of a referenced object's lifetime.

code: template<ESPMode Mode> class FWeakReferencer


className: IDebugHelper

description: Helper classes to help debugger visualization.

code: struct IDebugHelper


description: Creates a copy of itself into the storage and returns a pointer to the new object within it.

code: void * CloneToEmptyStorage ( void * Storage ) const


description: Destructor.

code: void Destroy()


description: Returns the address of the object.

code: void * GetAddress()


description: Destructor.

code: virtual ~IFunction_OwnedObject()


description: Common interface to a callable object owned byTFunction.

code: struct IFunction_OwnedObject


description: Destructor.

code: virtual void Destroy()


code: template<typename T> struct IFunction_OwnedObject_Inline : public [UE::Core::Private::Function::IFunction_OwnedObject](API\Runtime\Core\Templates\IFunction_OwnedObject)


code: template<typename T> struct IFunction_OwnedObject_OnHeap : public [UE::Core::Private::Function::IFunction_OwnedObject](API\Runtime\Core\Templates\IFunction_OwnedObject)


className: IRefCountedObject

description: A virtual interface for ref counted objects to implement.

code: class IRefCountedObject


description: Creates an intrusive reference controller

code: namespace SharedPointerInternals { template<ESPMode Mode, typename ObjectType, typename... ArgTypes> [TIntrusiveReferenceController](API\Runtime\Core\Templates\TIntrusiveReferenceController)< ObjectType, Mode > * SharedPointerInternals::NewIntrusiveReferenceController ( ArgTypes &&... Args ) }


description: Templated helper catch-all function, accomplice to the above helper functions

code: namespace SharedPointerInternals { void SharedPointerInternals::EnableSharedFromThis ( ... ) }


description: Templated helper function (const) that creates a shared pointer from an object instance

code: namespace SharedPointerInternals { template<class SharedPtrType, class ObjectType, class OtherType, ESPMode Mode> void SharedPointerInternals::EnableSharedFromThis ( [TSharedPtr](API\Runtime\Core\Templates\TSharedPtr)< SharedPtrType, Mode > const * InSharedPtr, ObjectType const * InObject, [TSharedFromThis](API\Runtime\Core\Templates\TSharedFromThis)< OtherType, Mode > const * InShareable ) }


description: Templated helper function that creates a shared pointer from an object instance

code: namespace SharedPointerInternals { template<class SharedPtrType, class ObjectType, class OtherType, ESPMode Mode> void SharedPointerInternals::EnableSharedFromThis ( [TSharedPtr](API\Runtime\Core\Templates\TSharedPtr)< SharedPtrType, Mode > * InSharedPtr, ObjectType const * InObject, [TSharedFromThis](API\Runtime\Core\Templates\TSharedFromThis)< OtherType, Mode > const * InShareable ) }


description: Templated helper function (const) that creates a shared reference from an object instance

code: namespace SharedPointerInternals { template<class SharedRefType, class ObjectType, class OtherType, ESPMode Mode> void SharedPointerInternals::EnableSharedFromThis ( [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< SharedRefType, Mode > const * InSharedRef, ObjectType const * InObject, [TSharedFromThis](API\Runtime\Core\Templates\TSharedFromThis)< OtherType, Mode > const * InShareable ) }


description: Templated helper function that creates a shared reference from an object instance

code: namespace SharedPointerInternals { template<class SharedRefType, class ObjectType, class OtherType, ESPMode Mode> void SharedPointerInternals::EnableSharedFromThis ( [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< SharedRefType, Mode > * InSharedRef, ObjectType const * InObject, [TSharedFromThis](API\Runtime\Core\Templates\TSharedFromThis)< OtherType, Mode > const * InShareable ) }


description: Creates a custom reference controller with a specified deleter

code: namespace SharedPointerInternals { template<ESPMode Mode, typename ObjectType, typename DeleterType> [TReferenceControllerBase](API\Runtime\Core\Templates\TReferenceControllerBase)< Mode > * SharedPointerInternals::NewCustomReferenceController ( ObjectType * Object, DeleterType && Deleter ) }


description: Creates a reference controller which just calls delete

code: namespace SharedPointerInternals { template<ESPMode Mode, typename ObjectType> [TReferenceControllerBase](API\Runtime\Core\Templates\TReferenceControllerBase)< Mode > * SharedPointerInternals::NewDefaultReferenceController ( ObjectType * Object ) }


className: tuple_size< TTuple< ArgTypes... > >

description: TTuplesupport for structured bindings - not intended to be used directly //.

code: template<typename... ArgTypes> struct tuple_size< TTuple< ArgTypes... > > : public std< std::size_t, sizeof...(ArgTypes)>::integral_constant


className: type

code: typedef typename TTupleElement< N, [TTuple](API\Runtime\Core\Misc\TTuple)< ArgTypes... >>::Type type


className: std

description: Libc++ 8.0 and older incorrectly defined std::tuple_element as class, whereas the standard says it should be a struct.

code: template<std::size_t N, typename... ArgTypes> class std : private tuple_elementendif< N, TTuple< ArgTypes... > >


className: TAnd

description: TAnd< LHS, RHS... >TAnd<>

code: template<typename... Types> struct TAnd


className: Value

code: static constexpr bool Value = TAnd<RHS...>::value;


className: value

code: static constexpr bool value = TAnd<RHS...>::value;


className: TAndValue

description: TAndValue< false, RHS... >

code: template<bool LHSValue, typename... RHS> struct TAndValue


className: TAndValue< false, RHS... >

code: template<typename... RHS> struct TAndValue< false, RHS... >


className: TAnd< LHS, RHS... >

code: template<typename LHS, typename... RHS> struct TAnd< LHS, RHS... > : public [TAndValue< LHS::Value, RHS... >](API\Runtime\Core\Templates\TAndValue)


className: TAlignedBytes

description: Used to declare an untyped array of data with compile-time alignment. It needs to use template specialization as the MS_ALIGN and GCC_ALIGN macros require literal parameters.

code: template<int32 Size, uint32 Alignment> struct TAlignedBytes


code: TArrayRange ( T * InPtr, int32 InSize )


className: TArrayRange

description: Wraps a range into a container like interface to satisfy the GetData and GetNum global functions. We're not usingTArrayViewsince it calls Sort creating a circular dependency.

code: template<typename T> struct TArrayRange


className: Type

code: typedef [TAtomicBase_Basic](API\Runtime\Core\Templates\TAtomicBase_Basic)< T > Type


className: TAtomicBaseType

code: template<typename T, bool bIsVoidPointer, bool bIsIntegral, bool bCanUsePlatformAtomics> struct TAtomicBaseType


code: typedef typename [TAtomicBaseType](API\Runtime\Core\Templates\TAtomicBaseType)< T, bIsVoidPointer, bIsIntegral, bCanUsePlatformAtomics >::Type TAtomicBaseType_T


code: typedef TAtomicBase_Mutex< T > Type


code: template<typename T> struct TAtomicBaseType< T, false, false, false >


code: typedef TAtomicBase_Integral< T > Type


className: TAtomicBaseType< T, false, true, true >

code: template<typename T> struct TAtomicBaseType< T, false, true, true >


code: typedef TAtomicBase_Pointer< T &42; > Type


code: template<typename T> struct TAtomicBaseType< T *, false, false, true >


description:
Adds Value to Element and returns a copy of the previous value of the element.
A copy of the previous, unincremented value.

code: T AddExchange ( DiffType Value )


description:
Decrements Element and returns a copy of the previous value of the element.
A copy of the previous, undecremented value.

code: T DecrementExchange()


description:
Increments Element and returns a copy of the previous value of the element.
A copy of the previous, unincremented value.

code: T IncrementExchange()


description:
Performs Element += Value, returning a copy of the new value of the element.
A copy of the new, incremented value.

code: T operator+= ( DiffType Value )


description:
Performs Element, returning a copy of the previous value of the element.
A copy of the previous, undecremented value.

code: T operator-- ( int )


description:
Performs Element++, returning a copy of the previous value of the element.
A copy of the previous, unincremented value.

code: T operator++ ( int )


description:
Performs Element, returning a copy of the new value of the element.
A copy of the new, decremented value.

code: T operator--()


description:
Performs ++Element, returning a copy of the new value of the element.
A copy of the new, incremented value.

code: T operator++()


description:
Performs Element -= Value, returning a copy of the new value of the element.
A copy of the new, decremented value.

code: T operator-= ( DiffType Value )


description:
Subtracts Value from Element and returns a copy of the previous value of the element.
A copy of the previous, undecremented value.

code: T SubExchange ( DiffType Value )


code: constexpr TAtomicBase_Arithmetic ( T Value )


description: Arithmetic atomic implementation - used by both pointers and integral types in addition to getting and setting.

code: template<typename T, typename DiffType> struct TAtomicBase_Arithmetic : public [TAtomicBase_Basic< T >](API\Runtime\Core\Templates\TAtomicBase_Basic)


description:
It is equivalent to this in non-atomic terms:
boolCompareExchange(T& Expected, T Value){ bool bResult = this->Element == Expected; Expected = this->Element; if (bResult) { this->Element = Value; } return bResult; }
Whether the element compared equal to Expected.

code: bool CompareExchange ( T & Expected, T Value )


description:
Sets the element to a specific value, returning a copy of the previous value.
A copy of the previous value.

code: T Exchange ( T Value )


description:
Gets a copy of the current value of the element.
The current value.

code: T Load ( EMemoryOrder Order ) const


description: Sets the element to a specific value.

code: void Store ( T Value, EMemoryOrder Order )


code: constexpr TAtomicBase_Basic ( T Value )


description: Basic storage and implementation - only allows getting and setting via platform atomics.

code: template<typename T> struct TAtomicBase_Basic

Element

type: T


description:
Performs Element &= Value, returning a copy of the previous value of the element.
A copy of the previous value.

code: T AndExchange ( const T Value )


description:
Performs Element &= Value, returning a copy of the new value of the element.
A copy of the new value.

code: T operator&= ( const T Value )


description:
Performs Element ^= Value, returning a copy of the new value of the element.
A copy of the new value.

code: T operator^= ( const T Value )


description:
Performs Element |= Value, returning a copy of the previous value of the element.
A copy of the previous value.

code: T OrExchange ( const T Value )


description:
Performs Element ^= Value, returning a copy of the previous value of the element.
A copy of the previous value.

code: T XorExchange ( const T Value )


code: constexpr TAtomicBase_Integral ( T Value )


description: Integral atomic implementation - allows arithmetic and bitwise operations.

code: template<typename T> struct TAtomicBase_Integral : public [TAtomicBase_Arithmetic< T, T >](API\Runtime\Core\Templates\TAtomicBase_Arithmetic)


description: TODO : basic storage and getting and setting, but the element is protected by a mutex instead of using platform atomics. Also, we may not want to do this ever.

code: template<typename ElementType> struct TAtomicBase_Mutex


code: constexpr TAtomicBase_Pointer ( T Value )


description: Pointer atomic implementation - allows arithmetic with PTRINT.

code: template<typename T> struct TAtomicBase_Pointer : public [TAtomicBase_Arithmetic< T, PTRINT >](API\Runtime\Core\Templates\TAtomicBase_Arithmetic)


className: ConstPointerType

code: typedef [TCallTraitsParamTypeHelper](API\Runtime\Core\Templates\TCallTraitsParamTypeHelper)< T, PassByValue >::ConstParamType ConstPointerType


className: ConstReference

code: typedef const T & ConstReference


className: ParamType

code: typedef [TCallTraitsParamTypeHelper](API\Runtime\Core\Templates\TCallTraitsParamTypeHelper)< T, PassByValue >::[ParamType](API\Runtime\Core\Templates\TCallTraitsBase\ParamType) ParamType


className: TCallTraitsBase

description: TRemoveConst<> is modeled after boost's implementation. It allows you to take a templatized type such as 'const Foo*' and use const_cast to convert that type to 'Foo*' without knowing about Foo. MutablePtr = const_cast< RemoveConst< ConstPtrType >::Type >( ConstPtr );base class for call traits. Used to more easily refine portions when specializing

code: template<class T> struct TCallTraitsBase


className: ConstParamType

code: typedef const T & ConstParamType


code: typedef const T & ParamType


className: TCallTraitsParamTypeHelper

code: template<typename T, bool TypeIsSmall> struct TCallTraitsParamTypeHelper


code: typedef const T ConstParamType


className: TCallTraitsParamTypeHelper< T, true >

code: template<typename T> struct TCallTraitsParamTypeHelper< T, true >


code: typedef const T &42; ConstParamType


className: TCallTraitsParamTypeHelper< T *, true >

code: template<typename T> struct TCallTraitsParamTypeHelper< T *, true >


code: typedef const T &42;const ConstPointerType


code: typedef const ArrayType & ConstReference


className: Reference

code: typedef ArrayType & Reference


code: typedef const T &42;const ParamType


className: ValueType

code: typedef const T &42; ValueType


className: TCallTraits< const T[N]>

description: Const array types

code: template<typename T, size_t N> struct TCallTraits< const T[N]>


code: typedef T & ConstPointerType


code: typedef const T & ConstReference


className: TCallTraits< T & >

description: Fix reference-to-reference problems.

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


className: TCallTraits< T[N]>

description: Array types.

code: template<typename T, size_t N> struct TCallTraits< T[N]>


className: Value

code: enum { Value = std::is_same_v<DestinationElementType, SourceElementType> || TAnd< TIsBitwiseConstructible<DestinationElementType, SourceElementType>, TIsTriviallyDestructible<SourceElementType> >::Value }


className: TCanBitwiseRelocate

code: template<typename DestinationElementType, typename SourceElementType> struct TCanBitwiseRelocate


className: TChooseClass

code: template<bool Predicate, typename TrueClass, typename FalseClass> class TChooseClass


code: template<typename TrueClass, typename FalseClass> class TChooseClass< false, TrueClass, FalseClass >


code: template<typename TrueClass, typename FalseClass> class TChooseClass< true, TrueClass, FalseClass >


className: Type

code: typedef typename [TCopyQualifiersFromTo](API\Runtime\Core\Templates\TCopyQualifiersFromTo)< From, To >::[Type](API\Runtime\Core\Templates\TCopyQualifiersAndRefsFromTo\Type) Type


className: TCopyQualifiersAndRefsFromTo

code: template<typename From, typename To> struct TCopyQualifiersAndRefsFromTo


code: typedef typename TCopyQualifiersFromTo< From, To >::Type & Type


code: template<typename From, typename To> struct TCopyQualifiersAndRefsFromTo< From &&, To & >


code: typedef typename TCopyQualifiersFromTo< From, To >::Type && Type


code: template<typename From, typename To> struct TCopyQualifiersAndRefsFromTo< From &&, To && >


code: template<typename From, typename To> struct TCopyQualifiersAndRefsFromTo< From &&, To >


code: template<typename From, typename To> struct TCopyQualifiersAndRefsFromTo< From &, To & >


code: template<typename From, typename To> struct TCopyQualifiersAndRefsFromTo< From &, To && >


code: template<typename From, typename To> struct TCopyQualifiersAndRefsFromTo< From &, To >


code: template<typename From, typename To> struct TCopyQualifiersAndRefsFromTo< From, To & >


code: template<typename From, typename To> struct TCopyQualifiersAndRefsFromTo< From, To && >


className: TCopyQualifiersFromTo

code: template<typename From, typename To> struct TCopyQualifiersFromTo


className: TCopyQualifiersFromTo< const                                                                  From, To >

code: template<typename From, typename To> struct TCopyQualifiersFromTo< const From, To >


code: template<typename From, typename To> struct TCopyQualifiersFromTo< const volatile From, To >


code: template<typename From, typename To> struct TCopyQualifiersFromTo< volatile From, To >


className: TCVTupleArity

code: template<typename TupleType> struct TCVTupleArity


className: TCVTupleElement

code: template<uint32 Index, typename TupleType> struct TCVTupleElement


className: TCVTupleIndex

code: template<typename Type, typename TupleType> struct TCVTupleIndex


code: static constexpr uint32 Value = 0;


className: TDebugHelper

code: template<typename T> struct TDebugHelper : public [UE::Core::Private::Function::IDebugHelper](API\Runtime\Core\Templates\IDebugHelper)

Ptr

type: T *


code: typedef std::remove_cv_t< T > Type


className: TDecayNonReference

description: TDecayNonReference< RetType(Params...)>TDecayNonReference< T[]>TDecayNonReference< T[N]>

code: template<typename T> struct TDecayNonReference


className: TDecayNonReference< RetType(Params...)>

code: template<typename RetType, typename... Params> struct TDecayNonReference< RetType(Params...)>


className: TDecayNonReference< T[]>

code: template<typename T> struct TDecayNonReference< T[]>


className: TDecayNonReference< T[N]>

code: template<typename T, uint32 N> struct TDecayNonReference< T[N]>


className: CounterBase

code: static constexpr int CounterBase = __COUNTER__;


code: const [FTypeLayoutDesc](API\Runtime\Core\Serialization\FTypeLayoutDesc) & GetTypeLayout() const


className: InternalBaseType

code: typedef typename [TGetBaseTypeHelper](API\Runtime\Core\Serialization\TGetBaseTypeHelper)< [TDefaultDelete](API\Runtime\Core\Templates\TDefaultDelete) >::Type InternalBaseType


className: InterfaceType

code: static constexpr [ETypeLayoutInterface::Type](API\Runtime\Core\Serialization\ETypeLayoutInterface__Type) InterfaceType = ETypeLayoutInterface:: NonVirtual;


code: static void Initialize &40; FTypeLayoutDesc & TypeDesc &41;


className: InternalLinkType

code: template<int Counter> struct InternalLinkType


code: [TDefaultDelete](API\Runtime\Core\Templates\TDefaultDelete) & operator= ( const [TDefaultDelete](API\Runtime\Core\Templates\TDefaultDelete) & )


code: template<typename U, typename> [TDefaultDelete](API\Runtime\Core\Templates\TDefaultDelete) & operator= ( const [TDefaultDelete](API\Runtime\Core\Templates\TDefaultDelete)< U > & )


code: static [FTypeLayoutDesc](API\Runtime\Core\Serialization\FTypeLayoutDesc) & StaticGetTypeLayout()


code: TDefaultDelete ( const [TDefaultDelete](API\Runtime\Core\Templates\TDefaultDelete) & )


code: template<typename U, typename> TDefaultDelete ( const [TDefaultDelete](API\Runtime\Core\Templates\TDefaultDelete)< U > & )


className: TDefaultDelete< T[]>::operator()

code: template<typename U, typename> void operator&40;&41; &40; U &42; Ptr &41; const


className: TDefaultDelete

description: TDefaultDelete< T[]>

code: template<typename T> struct TDefaultDelete


className: TDefaultDelete< T[]>::operator=

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


code: template<typename U, typename> TDefaultDelete & operator&61; &40; const TDefaultDelete< U[]> & &41;


className: TDefaultDelete< T[]>::TDefaultDelete


code: TDefaultDelete &40; const TDefaultDelete & &41;


code: template<typename U, typename> TDefaultDelete &40; const TDefaultDelete< U[]> & &41;


className: TDefaultDelete< T[]>::~TDefaultDelete


className: TDefaultDelete< T[]>

code: template<typename T> struct TDefaultDelete< T[]>


code: template<typename ObjectType> void InvokeDeleter ( ObjectType * Object )


code: TDeleterHolder ( DeleterType && Arg )


className: TDeleterHolder

description: TDeleterHolder< DeleterType, false >

code: template<typename DeleterType, bool bIsZeroSize> struct TDeleterHolder : private DeleterType


className: TDeleterHolder< DeleterType, false >::InvokeDeleter

code: template<typename ObjectType> void InvokeDeleter &40; ObjectType &42; Object &41;


className: TDeleterHolder< DeleterType, false >::TDeleterHolder

code: TDeleterHolder &40; DeleterType && Arg &41;


className: TDeleterHolder< DeleterType, false >

code: template<typename DeleterType> struct TDeleterHolder< DeleterType, false >


description: Pass through for non-pointer types

code: bool operator() ( T & A, T & B )


code: bool operator() ( const T & A, const T & B ) const


code: TDereferenceWrapper ( const PREDICATE_CLASS & InPredicate )


className: TDereferenceWrapper

description: TDereferenceWrapper< T *, PREDICATE_CLASS >

code: template<typename T, class PREDICATE_CLASS> struct TDereferenceWrapper

Predicate

type: const PREDICATE...


className: TDereferenceWrapper< T *, PREDICATE_CLASS >::operator()

description: Dereference pointers


className: TDereferenceWrapper< T *, PREDICATE_CLASS >::TDereferenceWrapper

code: TDereferenceWrapper &40; const PREDICATE_CLASS & InPredicate &41;


description: Partially specialized version of the above class

code: template<typename T, class PREDICATE_CLASS> struct TDereferenceWrapper< T *, PREDICATE_CLASS >


code: [TDontCopy](API\Runtime\Core\Templates\TDontCopy) & operator= ( [TDontCopy](API\Runtime\Core\Templates\TDontCopy) && )


code: [TDontCopy](API\Runtime\Core\Templates\TDontCopy) & operator= ( const [TDontCopy](API\Runtime\Core\Templates\TDontCopy) & )


code: TDontCopy ( [TDontCopy](API\Runtime\Core\Templates\TDontCopy) && )


code: TDontCopy ( const [TDontCopy](API\Runtime\Core\Templates\TDontCopy) & )


className: TDontCopy

description: Can be used as a wrapper over non-copyable objects (i.e. FCriticalSection) if you still want the class containing your object to keep its copyable property without compromising integrity of the object that doesn't support being copied. It makes eachTDontCopymember of a class an exclusive entity of that class.

code: template<typename T> struct TDontCopy


className: TEnableIf

code: template<bool Predicate, typename Result> class TEnableIf


className: TEnableIf< false, Result >

code: template<typename Result> class TEnableIf< false, Result >


code: constexpr auto operator() ( const T & Lhs, const T & Rhs ) const


className: TEnableIf< true, Result >

code: template<typename Result> class TEnableIf< true, Result >


className: TEqualTo< void >::operator()

code: template<typename T, typename U> constexpr auto operator&40;&41; &40; T && Lhs, U && Rhs &41; const


className: TEqualTo< void >

code: template<> struct TEqualTo< void >


className: TForceInitAtBoot

description: Template for initializing a singleton at the boot.

code: template<class T> struct TForceInitAtBoot


code: static TCHAR const * GetFormatSpecifier()


className: TFormatSpecifier< bool >

code: template<> struct TFormatSpecifier< bool >


className: TFormatSpecifier< double >

code: template<> struct TFormatSpecifier< double >


className: TEqualTo

description: TEqualTo< void >

code: template<typename T> struct TEqualTo


className: TFormatSpecifier< float >

code: template<> struct TFormatSpecifier< float >


className: TFormatSpecifier< int16 >

code: template<> struct TFormatSpecifier< int16 >


className: TFormatSpecifier< int32 >

code: template<> struct TFormatSpecifier< int32 >


className: TFormatSpecifier

code: template<typename T> struct TFormatSpecifier


className: TFormatSpecifier< int64 >

code: template<> struct TFormatSpecifier< int64 >


className: TFormatSpecifier< int8 >

code: template<> struct TFormatSpecifier< int8 >


className: TFormatSpecifier< long >

code: template<> struct TFormatSpecifier< long >


className: TFormatSpecifier< long double >::GetFormatSpecifier


className: TFormatSpecifier< long double >

code: template<> struct TFormatSpecifier< long double >


className: TFormatSpecifier< uint16 >

code: template<> struct TFormatSpecifier< uint16 >


className: TFormatSpecifier< uint32 >

code: template<> struct TFormatSpecifier< uint32 >


className: TFormatSpecifier< uint8 >

code: template<> struct TFormatSpecifier< uint8 >


className: TFormatSpecifier< unsigned long >::GetFormatSpecifier


className: TFormatSpecifier< unsigned long >

code: template<> struct TFormatSpecifier< unsigned long >


className: TFuncCanBindToFunctor

code: template<typename FuncType, typename FunctorType> struct TFuncCanBindToFunctor


code: template<typename FunctorType, typename Ret, typename... ParamTypes> struct TFuncCanBindToFunctor< Ret(ParamTypes...), FunctorType > : public [TAnd< TIsInvocable< FunctorType, ParamTypes... >, TFunctorReturnTypeIsCompatible< FunctorType, Ret, ParamTypes... > >](API\Runtime\Core\Templates\TAnd)


className: TFormatSpecifier< uint64 >

code: template<> struct TFormatSpecifier< uint64 >


code: template<typename FunctorType, typename... ParamTypes> struct TFuncCanBindToFunctor< void(ParamTypes...), FunctorType > : public [TIsInvocable< FunctorType, ParamTypes... >](API\Runtime\Core\Templates\TIsInvocable)


className: TFunctionRefBase

description: TFunctionRefBase< StorageType, Ret(ParamTypes...)>

code: template<typename StorageType, typename FuncType> struct TFunctionRefBase


description: Move all of the assert code out of line.

code: void CheckCallable&40;&41; const


code: Ret operator&40;&41; &40; ParamTypes... Params &41; const


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


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


code: TFunctionRefBase &40; TFunctionRefBase && Other &41;


code: template<typename OtherStorage> TFunctionRefBase &40; TFunctionRefBase< OtherStorage, Ret(ParamTypes...)> && Other &41;


code: template<typename FunctorType UE_REQUIRES> TFunctionRefBase &40; FunctorType && InFunc &41;


code: template<typename OtherStorage> TFunctionRefBase &40; const TFunctionRefBase< OtherStorage, Ret(ParamTypes...)> & Other &41;


code: TFunctionRefBase &40; const TFunctionRefBase & Other &41;


code: template<typename StorageType, typename Ret, typename... ParamTypes> struct TFunctionRefBase< StorageType, Ret(ParamTypes...)>


className: TFunctionRefCaller

description: TFunctionRefCaller< Functor, Ret(ParamTypes...)>TFunctionRefCaller< Functor, void(ParamTypes...)>

code: template<typename Functor, typename FuncType> struct TFunctionRefCaller


code: static Ret Call &40; void &42; Obj, ParamTypes &... Params &41;


code: template<typename Functor, typename Ret, typename... ParamTypes> struct TFunctionRefCaller< Functor, Ret(ParamTypes...)>


code: static void Call &40; void &42; Obj, ParamTypes &... Params &41;


code: template<typename Functor, typename... ParamTypes> struct TFunctionRefCaller< Functor, void(ParamTypes...)>


code: template<typename FunctorType> [TDecay](API\Runtime\Core\ProfilingDebugging\TDecay)< FunctorType >::Type * Bind ( FunctorType && InFunc )


code: TFunctionStorage ( [FFunctionStorage](API\Runtime\Core\Templates\FFunctionStorage) && Other )


className: TFunctionStorage

code: template<bool bUnique> struct TFunctionStorage : public [UE::Core::Private::Function::FFunctionStorage](API\Runtime\Core\Templates\FFunctionStorage)


code: void * CloneToEmptyStorage ( void * UntypedStorage ) const


description: Constructor which creates its T by copying.

code: TFunction_CopyableOwnedObject ( const T & InObj )


description: Constructor which creates its T by moving.

code: TFunction_CopyableOwnedObject ( T && InObj )


description: Implementation ofIFunction_OwnedObjectfor a given copyable T.

code: template<typename T, bool bOnHeap> struct TFunction_CopyableOwnedObject : public [UE::Core::Private::Function::TFunction_OwnedObject< T, bOnHeap >](API\Runtime\Core\Templates\TFunction_OwnedObject)


code: template<typename... ArgTypes> TFunction_OwnedObject ( ArgTypes &&... Args )


code: template<typename T, bool bOnHeap> struct TFunction_OwnedObject : public TChooseClass< bOnHeap, IFunction_OwnedObject_OnHeap< T >, IFunction_OwnedObject_Inline< T > >::Result


code: void * CloneToEmptyStorage ( void * Storage ) const


code: TFunction_UniqueOwnedObject ( T && InObj )


description: Implementation ofIFunction_OwnedObjectfor a given non-copyable T.

code: template<typename T, bool bOnHeap> struct TFunction_UniqueOwnedObject : public [UE::Core::Private::Function::TFunction_OwnedObject< T, bOnHeap >](API\Runtime\Core\Templates\TFunction_OwnedObject)


className: TFunctorReturnTypeIsCompatible

description: TFunctorReturnTypeIsCompatible< MemberRet Class::, Ret, ParamTypes... >](API\Runtime\Core\Templates\TFunctorReturnTy-)[TFunctorReturnTypeIsCompatible< MemberRet Class::const, Ret, ParamTypes... >TFunctorReturnTypeIsCompatible< MemberRet(Class::)(MemberParamTypes...) const, Ret, ParamTypes... >](API\Runtime\Core\Templates\TFunctorReturnTy-_2)[TFunctorReturnTypeIsCompatible< MemberRet(Class::)(MemberParamTypes...), Ret, ParamTypes... >

code: template<typename FunctorType, typename Ret, typename... ParamTypes> struct TFunctorReturnTypeIsCompatible : public [TIsConstructible< Ret, decltype(DeclVal< FunctorType >()(DeclVal< ParamTypes >()...))>](API\Runtime\Core\Templates\TIsConstructible)


code: template<typename TupleType> static uint32 Do ( uint32 Hash, const TupleType & Tuple )


className: TGetTupleHashHelper

description: TGetTupleHashHelper< ArgIndex, ArgIndex >

code: template<uint32 ArgToCombine, uint32 ArgCount> struct TGetTupleHashHelper


className: TGetTupleHashHelper< ArgIndex, ArgIndex >::Do

code: template<typename TupleType> static uint32 Do &40; uint32 Hash, const TupleType & Tuple &41;


code: template<uint32 ArgIndex> struct TGetTupleHashHelper< ArgIndex, ArgIndex >


code: bool operator() ( const T & A, const T & B ) const


className: TGreater< void >

code: template<> struct TGreater< void >


className: TGreater< void >::operator()

code: template<typename T, typename U> bool operator&40;&41; &40; T && A, U && B &41; const


description:
Overloaded dereference operator. Provides read-only access to the original value of the data being tracked by this struct
a const reference to the original data value

code: const AssignedType & operator*() const


code: TGuardValue ( RefType & ReferenceValue, const AssignedType & NewValue )


className: TGuardValue

description: Exception-safe guard around saving/restoring a value. Commonly used to make sure a value is restored even if the code early outs in the future. Usage:TGuardValueGuardSomeBool(bSomeBool, false); // Sets bSomeBool to false, and restores it in dtor.

code: template<typename RefType, typename AssignedType> struct TGuardValue : private [FNoncopyable](API\Runtime\Core\Templates\FNoncopyable)


code: TGuardValue_Bitfield_Cleanup ( FuncType && InFunc )


className: TGreater

description: TGreater< void >

code: template<typename T> struct TGreater


code: template<typename FuncType> struct TGuardValue_Bitfield_Cleanup : public [FNoncopyable](API\Runtime\Core\Templates\FNoncopyable)


className: TIdentity

code: template<typename T> struct TIdentity


className: Value

code: enum { Value = sizeof(Test((From*)nullptr)) - 1 }


className: TImpl

code: template<typename From, typename To, typename NoCVFrom, typename NoCVTo> struct TImpl


description: Cv T* to cv T* conversions are always allowed as long as no CVs are lost

code: enum &123; Value = !TLosesQualifiersFromTo<From, To>::Value &125;


className: TImpl< From, To, NoCVFrom, NoCVFrom >

code: template<typename From, typename To, typename NoCVFrom> struct TImpl< From, To, NoCVFrom, NoCVFrom >


description: Cv T* to cv void* conversions are always allowed as long as no CVs are lost


className: TImpl< From, To, NoCVFrom, void >

code: template<typename From, typename To, typename NoCVFrom> struct TImpl< From, To, NoCVFrom, void >


description: Cv void* to cv not_void* conversions are never legal

code: enum &123; Value = false &125;


className: TImpl< From, To, void, NoCVTo >

code: template<typename From, typename To, typename NoCVTo> struct TImpl< From, To, void, NoCVTo >


description: Cv void* to cv void* conversions are always allowed as long as no CVs are lost


className: TImpl< From, To, void, void >

code: template<typename From, typename To> struct TImpl< From, To, void, void >


code: static constexpr T Value = Val;


className: TIntegralConstant

description: Defines a value metafunction of the given Value.

code: template<typename T, T Val> struct TIntegralConstant


code: [TIntrusiveReferenceController](API\Runtime\Core\Templates\TIntrusiveReferenceController) & operator= ( const [TIntrusiveReferenceController](API\Runtime\Core\Templates\TIntrusiveReferenceController) & )


code: template<typename... ArgTypes> TIntrusiveReferenceController ( ArgTypes &&... Args )


description: Non-copyable.

code: TIntrusiveReferenceController ( const [TIntrusiveReferenceController](API\Runtime\Core\Templates\TIntrusiveReferenceController) & )


className: TIntrusiveReferenceController

code: template<typename ObjectType, ESPMode Mode> class TIntrusiveReferenceController : public [SharedPointerInternals::TReferenceControllerBase< Mode >](API\Runtime\Core\Templates\TReferenceControllerBase)


description: Destroys the object associated with this reference counter.

code: virtual void DestroyObject()


className: TInvokeResult

description: Trait for the type of the result when invoking a callable with the given argument types. Not defined (and thus usable in SFINAE contexts) when the callable cannot be invoked with the given argument types.

code: template<typename FuncType, typename... ArgTypes> struct TInvokeResult : public [UE::Core::Private::TInvokeResult_Impl< void, FuncType, ArgTypes... >](API\Runtime\Core\Templates\TInvokeResult_Impl)


code: template<typename, typename FuncType, typename... ArgTypes> struct TInvokeResult_Impl


code: enum { Value = __is_abstract(T) }


className: TIsAbstract

description: Traits class which tests if a type is abstract.

code: template<typename T> struct TIsAbstract


className: TIsArithmetic

code: template<typename T> struct TIsArithmetic


className: TIsArithmetic< ANSICHAR >

code: template<> struct TIsArithmetic< ANSICHAR >


code: enum &123; Value = TIsArithmetic<T>::Value &125;


className: TIsArithmetic< bool >

code: template<> struct TIsArithmetic< bool >


className: TIsArithmetic< const                                                                  T >

code: template<typename T> struct TIsArithmetic< const T >


className: TIsArithmetic< const volatile T >

code: template<typename T> struct TIsArithmetic< const volatile T >


className: TIsArithmetic< double >

code: template<> struct TIsArithmetic< double >


className: TIsArithmetic< float >

code: template<> struct TIsArithmetic< float >


className: TIsArithmetic< int16 >

code: template<> struct TIsArithmetic< int16 >


className: TIsArithmetic< int32 >

code: template<> struct TIsArithmetic< int32 >


className: TIsArithmetic< int64 >

code: template<> struct TIsArithmetic< int64 >


className: TIsArithmetic< int8 >

code: template<> struct TIsArithmetic< int8 >


className: TIsArithmetic< long >

code: template<> struct TIsArithmetic< long >


className: TIsArithmetic< long double >

code: template<> struct TIsArithmetic< long double >


className: TIsArithmetic< uint16 >

code: template<> struct TIsArithmetic< uint16 >


className: TIsArithmetic< uint32 >

code: template<> struct TIsArithmetic< uint32 >


className: TIsArithmetic< uint64 >

code: template<> struct TIsArithmetic< uint64 >


className: TIsArithmetic< uint8 >

code: template<> struct TIsArithmetic< uint8 >


className: TIsArithmetic< unsigned long >

code: template<> struct TIsArithmetic< unsigned long >


className: Value

code: enum &123; Value = TIsArithmetic<T>::Value &125;


className: TIsArithmetic<                                  volatile T >

code: template<typename T> struct TIsArithmetic< volatile T >


className: TIsArithmetic< WIDECHAR >

code: template<> struct TIsArithmetic< WIDECHAR >


className: TIsArray

description: TIsArray< T[]>TIsArray< T[N]>

code: template<typename T> struct TIsArray


code: enum &123; Value = Predicate<ArrType>::Value &125;


code: template<typename ArrType, unsigned int N, template< typename > class Predicate> struct TIsArrayOrRefOfTypeByPredicate< volatile ArrType(&)[N], Predicate >


code: template<typename ArrType, template< typename > class Predicate> struct TIsArrayOrRefOfTypeByPredicate< volatile ArrType[], Predicate >


code: template<typename ArrType, unsigned int N, template< typename > class Predicate> struct TIsArrayOrRefOfTypeByPredicate< volatile ArrType[N], Predicate >


code: template<typename ArrType, unsigned int N, template< typename > class Predicate> struct TIsArrayOrRefOfTypeByPredicate< const ArrType(&)[N], Predicate >


code: template<typename ArrType, unsigned int N, template< typename > class Predicate> struct TIsArrayOrRefOfTypeByPredicate< const ArrType[N], Predicate >


code: template<typename ArrType, template< typename > class Predicate> struct TIsArrayOrRefOfTypeByPredicate< const ArrType[], Predicate >


code: template<typename ArrType, unsigned int N, template< typename > class Predicate> struct TIsArrayOrRefOfTypeByPredicate< const volatile ArrType(&)[N], Predicate >


code: template<typename ArrType, template< typename > class Predicate> struct TIsArrayOrRefOfTypeByPredicate< const volatile ArrType[], Predicate >


code: template<typename ArrType, unsigned int N, template< typename > class Predicate> struct TIsArrayOrRefOfTypeByPredicate< const volatile ArrType[N], Predicate >


className: TIsArrayOrRefOfType

code: template<typename T, typename ArrType> struct TIsArrayOrRefOfType


className: TIsArrayOrRefOfTypeByPredicate

code: template<typename T, template< typename > class Predicate> struct TIsArrayOrRefOfTypeByPredicate


code: template<typename ArrType, unsigned int N, template< typename > class Predicate> struct TIsArrayOrRefOfTypeByPredicate< ArrType(&)[N], Predicate >


code: template<typename ArrType, template< typename > class Predicate> struct TIsArrayOrRefOfTypeByPredicate< ArrType[], Predicate >


code: template<typename ArrType, unsigned int N, template< typename > class Predicate> struct TIsArrayOrRefOfTypeByPredicate< ArrType[N], Predicate >


code: template<typename ArrType, unsigned int N> struct TIsArrayOrRefOfType< ArrType[N], ArrType >


code: template<typename ArrType> struct TIsArrayOrRefOfType< ArrType[], ArrType >


code: template<typename ArrType, unsigned int N> struct TIsArrayOrRefOfType< ArrType(&)[N], ArrType >


code: template<typename ArrType> struct TIsArrayOrRefOfType< const ArrType[], ArrType >


code: template<typename ArrType, unsigned int N> struct TIsArrayOrRefOfType< const ArrType(&)[N], ArrType >


code: template<typename ArrType, unsigned int N> struct TIsArrayOrRefOfType< const ArrType[N], ArrType >


code: template<typename ArrType, unsigned int N> struct TIsArrayOrRefOfType< const volatile ArrType(&)[N], ArrType >


code: template<typename ArrType, unsigned int N> struct TIsArrayOrRefOfType< const volatile ArrType[N], ArrType >


code: template<typename ArrType> struct TIsArrayOrRefOfType< const volatile ArrType[], ArrType >


code: template<typename ArrType, unsigned int N> struct TIsArrayOrRefOfType< volatile ArrType(&)[N], ArrType >


code: template<typename ArrType> struct TIsArrayOrRefOfType< volatile ArrType[], ArrType >


code: template<typename ArrType, unsigned int N> struct TIsArrayOrRefOfType< volatile ArrType[N], ArrType >


className: TIsArray< T[]>

code: template<typename T> struct TIsArray< T[]>


className: TIsArray< T[N]>

code: template<typename T, uint32 N> struct TIsArray< T[N]>


description: Assume no bitwise construction in general.

code: enum { Value = false }


className: TIsBitwiseConstructible

code: template<typename T, typename Arg> struct TIsBitwiseConstructible


className: TIsBitwiseConstructible< const T, U >

code: template<typename T, typename U> struct TIsBitwiseConstructible< const T, U > : public [TIsBitwiseConstructible< T, U >](API\Runtime\Core\Templates\TIsBitwiseConstructible)


description: Constructing a const T is the same as constructing a T.

code: enum &123; Value = true &125;


description: Const pointers can be bitwise constructed from non-const pointers. This is not true for pointer conversions in general, e.g. where an offset may need to be applied in the case of multiple inheritance, but there is no way of detecting that at compile-time.

code: template<typename T> struct TIsBitwiseConstructible< const T *, T * >


code: template<> struct TIsBitwiseConstructible< int16, uint16 >


code: template<> struct TIsBitwiseConstructible< int32, uint32 >


code: template<> struct TIsBitwiseConstructible< int64, uint64 >


description: Ts can always be bitwise constructed from itself if it is trivially copyable.

code: enum &123; Value = TIsTriviallyCopyConstructible<T>::Value &125;


className: TIsBitwiseConstructible< int8, uint8 >

code: template<> struct TIsBitwiseConstructible< int8, uint8 >


className: TIsBitwiseConstructible< T, T >

code: template<typename T> struct TIsBitwiseConstructible< T, T >


code: template<> struct TIsBitwiseConstructible< uint16, int16 >


code: template<> struct TIsBitwiseConstructible< uint64, int64 >


code: template<> struct TIsBitwiseConstructible< uint32, int32 >


className: TIsBitwiseConstructible< uint8,   int8 >

description: Unsigned types can be bitwise converted to their signed equivalents, and vice versa. (assuming two's-complement, which we are)

code: template<> struct TIsBitwiseConstructible< uint8, int8 >


className: TIsBoundedArray

description: TIsBoundedArray< T[N]>

code: template<typename T> struct TIsBoundedArray


className: TIsBoundedArray< T[N]>

code: template<typename T, uint32 N> struct TIsBoundedArray< T[N]>


code: enum { Value = !__is_union(T) && sizeof(Func<T>(0)) - 1 }


className: TIsClass

description: Determines if T is a struct/class type

code: template<typename T> struct TIsClass


code: static constexpr bool Value = false;


className: TIsConst

description: TIsConst< const T >

code: template<typename T> struct TIsConst


className: Value

code: enum { Value = __is_constructible(T, Args...) }


className: TIsConstructible

description: Determines if T is constructible from a set of arguments.

code: template<typename T, typename... Args> struct TIsConstructible


className: TIsConst< const T >

code: template<typename T> struct TIsConst< const T >


description: Makes a DerivedType ptr.

code: static DerivedType * DerivedTypePtr()


className: IsDerived

code: static constexpr bool IsDerived = Value;


className: No

description: Different size types so we can compare their sizes later.

code: typedef char No


description: OverloadingTest()s.t. only calling it with something that is a BaseType (or inherited from the BaseType) will return a Yes.

code: static [Yes](API\Runtime\Core\Templates\TIsDerivedFrom\Yes) & Test ( BaseType * )


code: static [Yes](API\Runtime\Core\Templates\TIsDerivedFrom\Yes) & Test ( const BaseType * )


code: static [No](API\Runtime\Core\Templates\TIsDerivedFrom\No) & Test ( ... )


description: Test the derived type pointer. If it inherits from BaseType, theTest( BaseType* )will be chosen. If it does not, Test( ... ) will be chosen.

code: static constexpr bool Value = sizeof(Test( DerivedTypePtr() )) == sizeof(Yes);


className: TIsDerivedFrom

description: Is type DerivedType inherited from BaseType.

code: template<typename DerivedType, typename BaseType> struct TIsDerivedFrom


className: TIsEnum

code: template<typename T> struct TIsEnum


className: TIsEnumClass

description: Traits class which tests if a type is arithmetic.

code: template<typename T> struct TIsEnumClass


code: enum { Value = sizeof(Resolve(T())) - 1 }


className: TIsEnumConvertibleToInt

code: template<typename T> struct TIsEnumConvertibleToInt


className: TIsFloatingPoint

code: template<typename T> struct TIsFloatingPoint


code: enum &123; Value = TIsFloatingPoint<T>::Value &125;


className: TIsFloatingPoint< const                                                                  T >

code: template<typename T> struct TIsFloatingPoint< const T >


className: TIsFloatingPoint< double >

code: template<> struct TIsFloatingPoint< double >


className: TIsFloatingPoint< float >

code: template<> struct TIsFloatingPoint< float >


className: TIsFloatingPoint< long double >

code: template<> struct TIsFloatingPoint< long double >


className: TIsFloatingPoint< const volatile T >

code: template<typename T> struct TIsFloatingPoint< const volatile T >


className: TIsFloatingPoint<                                  volatile T >

code: template<typename T> struct TIsFloatingPoint< volatile T >


className: TIsFunction

description: TIsFunction< RetType(Params...)>

code: template<typename T> struct TIsFunction


className: TIsFunction< RetType(Params...)>

code: template<typename RetType, typename... Params> struct TIsFunction< RetType(Params...)>


className: Value

code: enum { Value = TIsArithmetic<T>::Value || std::is_void_v<T> }


className: TIsFundamentalType

description: TIsFundamentalType

code: template<typename T> struct TIsFundamentalType


code: static constexpr bool Value = false;


className: TIsInitializerList

code: template<typename T> struct TIsInitializerList


code: enum &123; Value = TIsInitializerList<T>::Value &125;


className: TIsInitializerList< const                                                                  T >

code: template<typename T> struct TIsInitializerList< const T >


className: TIsInitializerList< const volatile T >

code: template<typename T> struct TIsInitializerList< const volatile T >


className: TIsInitializerList<                                  volatile T >

code: template<typename T> struct TIsInitializerList< volatile T >


className: TIsIntegral

code: template<typename T> struct TIsIntegral


className: TIsIntegral<                                                          bool >

code: template<> struct TIsIntegral< bool >


className: TIsIntegral<                                                          char >

code: template<> struct TIsIntegral< char >


className: TIsIntegral<                                                          char16_t >

code: template<> struct TIsIntegral< char16_t >


className: TIsIntegral<                                                          char32_t >

code: template<> struct TIsIntegral< char32_t >


code: enum &123; Value = TIsIntegral<T>::Value &125;


className: TIsIntegral< const                                                                  T >

code: template<typename T> struct TIsIntegral< const T >


className: TIsIntegral< const volatile T >

code: template<typename T> struct TIsIntegral< const volatile T >


className: TIsIntegral<                                                          int >

code: template<> struct TIsIntegral< int >


className: TIsIntegral<                                                          long >

code: template<> struct TIsIntegral< long >


className: TIsIntegral<                                                          long long >

code: template<> struct TIsIntegral< long long >


className: TIsIntegral<                                                          short >

code: template<> struct TIsIntegral< short >


className: TIsIntegral< signed   char >

code: template<> struct TIsIntegral< signed char >


className: TIsIntegral< unsigned char >

code: template<> struct TIsIntegral< unsigned char >


className: TIsIntegral< unsigned int >

code: template<> struct TIsIntegral< unsigned int >


className: TIsIntegral< unsigned long long >

code: template<> struct TIsIntegral< unsigned long long >


className: TIsIntegral< unsigned long >

code: template<> struct TIsIntegral< unsigned long >


className: TIsIntegral< unsigned short >

code: template<> struct TIsIntegral< unsigned short >


className: TIsIntegral<                                  volatile T >

code: template<typename T> struct TIsIntegral< volatile T >


className: TIsIntegral<                                                          wchar_t >

code: template<> struct TIsIntegral< wchar_t >


className: TIsInvocable

code: template<typename CallableType, typename... ArgTypes> struct TIsInvocable : public [UE::Core::Private::IsInvocable::TIsInvocableImpl< void, CallableType, ArgTypes... >](API\Runtime\Core\Templates\TIsInvocableImpl)


className: TIsInvocableImpl

code: template<typename, typename CallableType, typename... ArgTypes> struct TIsInvocableImpl


className: TIsLValueReferenceType

description: TIsLValueReferenceType< T & >

code: template<typename T> struct TIsLValueReferenceType


className: TIsLValueReferenceType< T & >

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


className: TIsMemberPointer< const                                                                  T >

code: template<typename T> struct TIsMemberPointer< const T >


className: TIsMemberPointer

code: template<typename T> struct TIsMemberPointer


className: Value

code: enum &123; Value = TIsPointer<T>::Value &125;


className: TIsMemberPointer< const volatile T >

code: template<typename T> struct TIsMemberPointer< const volatile T >


className: TIsMemberPointer< T U::* >

code: namespace TIsMemberPointer< T U { template<typename T, typename U> struct TIsMemberPointer< T U::* > }


className: TIsMemberPointer<                                  volatile T >

code: template<typename T> struct TIsMemberPointer< volatile T >


className: TIsNullableBinding

code: template<typename T> struct TIsNullableBinding : public [TOr< TIsPointer< T >, TIsMemberPointer< T >, TIsTFunction< T > >](API\Runtime\Core\Templates\TOr)


className: TIsPointer

code: template<typename T> struct TIsPointer


className: TIsPointer< const                                                                  T >

code: template<typename T> struct TIsPointer< const T >


className: TIsPointer< const volatile T >

code: template<typename T> struct TIsPointer< const volatile T >


className: TIsPointer< T * >

code: template<typename T> struct TIsPointer< T * >


className: TIsPointer<                                  volatile T >

code: template<typename T> struct TIsPointer< volatile T >


code: enum { Value = __is_polymorphic(T) }


className: TIsPolymorphic

description: Traits class which tests if a type is polymorphic (virtual).

code: template<typename T> struct TIsPolymorphic


className: TIsReferenceType< T & >

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


className: TIsReferenceType< T && >

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


className: TIsRValueReferenceType

description: TIsRValueReferenceType< T && >

code: template<typename T> struct TIsRValueReferenceType


className: TIsRValueReferenceType< T && >

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


className: TIsSigned

code: template<typename T> struct TIsSigned


code: enum &123; Value = TIsSigned<T>::Value &125;


className: TIsSigned< const                                                                  T >

code: template<typename T> struct TIsSigned< const T >


className: TIsReferenceType

description: TIsReferenceType< T & >TIsReferenceType< T && >

code: template<typename T> struct TIsReferenceType


className: TIsSigned< const volatile T >

code: template<typename T> struct TIsSigned< const volatile T >


className: TIsSigned< int16 >

code: template<> struct TIsSigned< int16 >


className: TIsSigned< int32 >

code: template<> struct TIsSigned< int32 >


className: TIsSigned< int64 >

code: template<> struct TIsSigned< int64 >


className: TIsSigned< int8 >

code: template<> struct TIsSigned< int8 >


className: TIsSigned<                                  volatile T >

code: template<typename T> struct TIsSigned< volatile T >


className: TIsSupportedSize

code: template<int Size> struct TIsSupportedSize


className: TIsTFunction

code: template<typename T> struct TIsTFunction


className: TIsTFunctionRef

code: template<typename T> struct TIsTFunctionRef


className: Value

code: enum &123; Value = TIsTFunctionRef<T>::Value &125;


className: TIsTFunctionRef< const                                                                  T >

code: template<typename T> struct TIsTFunctionRef< const T >


className: TIsTFunctionRef< const volatile T >

code: template<typename T> struct TIsTFunctionRef< const volatile T >


className: TIsTFunctionRef<                                  volatile T >

code: template<typename T> struct TIsTFunctionRef< volatile T >


code: enum &123; Value = TIsTFunction<T>::Value &125;


className: TIsTFunction< const                                                                  T >

code: template<typename T> struct TIsTFunction< const T >


className: TIsTFunction< const volatile T >

code: template<typename T> struct TIsTFunction< const volatile T >


className: TIsTFunction<                                  volatile T >

code: template<typename T> struct TIsTFunction< volatile T >


className: TIsTrivial

description: Traits class which tests if a type is trivial.

code: template<typename T> struct TIsTrivial


code: enum { Value = std::is_trivially_copy_assignable_v<T> }


code: enum { Value = std::is_trivially_copy_constructible_v<T> }


className: TIsTriviallyCopyAssignable

description: Traits class which tests if a type has a trivial copy assignment operator.

code: template<typename T> struct TIsTriviallyCopyAssignable


className: TIsTriviallyCopyConstructible

description: Traits class which tests if a type has a trivial copy constructor.

code: template<typename T> struct TIsTriviallyCopyConstructible


code: enum { Value = std::is_trivially_destructible_v<T> }


className: TIsTriviallyDestructible

description: Traits class which tests if a type has a trivial destructor.

code: template<typename T> struct TIsTriviallyDestructible


className: TIsTUniqueFunction

code: template<typename T> struct TIsTUniqueFunction


code: enum &123; Value = TIsTUniqueFunction<T>::Value &125;


className: TIsTUniqueFunction< const                                                                  T >

code: template<typename T> struct TIsTUniqueFunction< const T >


className: TIsTUniqueFunction< const volatile T >

code: template<typename T> struct TIsTUniqueFunction< const volatile T >


className: TIsTUniqueFunction<                                  volatile T >

code: template<typename T> struct TIsTUniqueFunction< volatile T >


className: TIsTuple

code: template<typename T> struct TIsTuple


code: enum { Value = TIsUECoreVariant<T>::Value }


className: TIsUECoreType

description: Traits class which tests if a type is part of the core types included in CoreMinimal.h.

code: template<typename T> struct TIsUECoreType


className: TIsUECoreVariant

code: template<typename T, typename, typename> struct TIsUECoreVariant


className: TIsUnboundedArray

description: TIsUnboundedArray< T[]>

code: template<typename T> struct TIsUnboundedArray


className: Value

code: enum { Value = sizeof(Tester(DeclValT())) == sizeof(uint32) }


className: TIsUnboundedArray< T[]>

code: template<typename T> struct TIsUnboundedArray< T[]>


className: TIsValidVariadicFunctionArg

code: template<typename T, bool> struct TIsValidVariadicFunctionArg


className: TIsValidVariadicFunctionArg< T, true >

code: template<typename T> struct TIsValidVariadicFunctionArg< T, true >


code: static constexpr bool Value = false;


className: TIsVoidPointer

code: template<typename T> struct TIsVoidPointer


className: TJugglingRotation

description: TGCDPolicy Policy for calculating greatest common divisor.

code: template<class TGCDPolicy> class TJugglingRotation


description: Rotates array.

code: template<class T> static void Rotate ( T * First, const int32 From, const int32 To, const int32 Amount )


code: bool operator== ( const [TKeyValuePair](API\Runtime\Core\Templates\TKeyValuePair) & Other ) const


code: bool operator() ( const [TKeyValuePair](API\Runtime\Core\Templates\TKeyValuePair) & A, const [TKeyValuePair](API\Runtime\Core\Templates\TKeyValuePair) & B ) const


code: bool operator< ( const [TKeyValuePair](API\Runtime\Core\Templates\TKeyValuePair) & Other ) const


code: bool operator!= ( const [TKeyValuePair](API\Runtime\Core\Templates\TKeyValuePair) & Other ) const


code: TKeyValuePair ( const KeyType & InKey )


code: TKeyValuePair ( const KeyType & InKey, const ValueType & InValue )


className: TKeyValuePair

description: Helper class to make it easy to use key/value pairs with a container.

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

Key

type: KeyType

Value

type: ValueType


className: TLazyEnableIf

code: template<bool Predicate, typename Func> class TLazyEnableIf


className: TLazyEnableIf< false, Func >

code: template<typename Func> class TLazyEnableIf< false, Func >


className: type

code: typedef typename Func::Type type


className: Type

code: typedef typename Func::Type Type


code: bool operator() ( const T & A, const T & B ) const


className: TLazyEnableIf< true, Func >

code: template<typename Func> class TLazyEnableIf< true, Func >


className: TLess

code: template<typename T> struct TLess


code: template<typename TupleType> static bool Do ( const TupleType & Lhs, const TupleType & Rhs )


className: TLessThanHelper< NumArgs, ArgToCompare, true >::Do

code: template<typename TupleType> static bool Do &40; const TupleType & Lhs, const TupleType & Rhs &41;


className: TLessThanHelper

code: template<uint32 NumArgs, uint32 ArgToCompare, bool Last> struct TLessThanHelper


code: template<uint32 NumArgs, uint32 ArgToCompare> struct TLessThanHelper< NumArgs, ArgToCompare, true >


code: template<uint32 NumArgs> struct TLessThanHelper< NumArgs, NumArgs, false >


className: TLess< void >::operator()

code: template<typename T, typename U> bool operator&40;&41; &40; T && A, U && B &41; const


className: TLess< void >

code: template<> struct TLess< void >


className: Value

code: enum { Value = !std::is_same_v<typename TCopyQualifiersFromTo<From, To>::Type, To> }


className: TLosesQualifiersFromTo

description: TLosesQualifiersFromTo::Value == true TLosesQualifiersFromTo::Value == false

code: template<typename From, typename To> struct TLosesQualifiersFromTo


className: TMakeSigned

code: template<typename T> struct TMakeSigned


code: typedef const typename TMakeSigned< T >::Type Type


className: TMakeSigned< const                                                                  T >

code: template<typename T> struct TMakeSigned< const T >


code: typedef const volatile typename TMakeSigned< T >::Type Type


className: TMakeSigned< const volatile T >

code: template<typename T> struct TMakeSigned< const volatile T >


className: TLessThanHelper< NumArgs, NumArgs, false >::Do


className: TMakeSigned< int16 >

code: template<> struct TMakeSigned< int16 >


className: TMakeSigned< int32 >

code: template<> struct TMakeSigned< int32 >


className: TMakeSigned< int64 >

code: template<> struct TMakeSigned< int64 >


className: TMakeSigned< int8 >

code: template<> struct TMakeSigned< int8 >


className: TMakeSigned< uint16 >

code: template<> struct TMakeSigned< uint16 >


className: TMakeSigned< uint32 >

code: template<> struct TMakeSigned< uint32 >


className: TMakeSigned< uint64 >

code: template<> struct TMakeSigned< uint64 >


className: TMakeSigned< uint8 >

code: template<> struct TMakeSigned< uint8 >


className: Type

code: typedef typename TMakeSigned< T >::Type Type


className: TMakeSigned<                                  volatile T >

code: template<typename T> struct TMakeSigned< volatile T >


className: TMakeUnsigned

code: template<typename T> struct TMakeUnsigned


className: TMakeUnsigned< const                                                                  T >

code: template<typename T> struct TMakeUnsigned< const T >


code: typedef const typename TMakeUnsigned< T >::Type Type


className: TMakeUnsigned< const volatile T >

code: template<typename T> struct TMakeUnsigned< const volatile T >


className: TMakeUnsigned< int16 >

code: template<> struct TMakeUnsigned< int16 >


className: TMakeUnsigned< int32 >

code: template<> struct TMakeUnsigned< int32 >


className: TMakeUnsigned< int64 >

code: template<> struct TMakeUnsigned< int64 >


code: typedef const volatile typename TMakeUnsigned< T >::Type Type


className: TMakeUnsigned< int8 >

code: template<> struct TMakeUnsigned< int8 >


className: TMakeUnsigned< uint16 >

code: template<> struct TMakeUnsigned< uint16 >


className: TMakeUnsigned< uint32 >

code: template<> struct TMakeUnsigned< uint32 >


className: TMakeUnsigned< uint64 >

code: template<> struct TMakeUnsigned< uint64 >


className: TMakeUnsigned< uint8 >

code: template<> struct TMakeUnsigned< uint8 >


code: typedef typename TMakeUnsigned< T >::Type Type


className: TMakeUnsigned<                                  volatile T >

code: template<typename T> struct TMakeUnsigned< volatile T >


className: TMaxSizeof

description: TMaxSizeof< T, TRest... >TMaxSizeof<>

code: template<typename...> struct TMaxSizeof


className: TMaxSizeof<>

code: template<> struct TMaxSizeof<>


className: Value

code: static Value = sizeof(T) > TMaxSizeof<TRest...>::Value ? sizeof(T) : TMaxSizeof<TRest...>::Value;


className: TMaxSizeof< T, TRest... >

code: template<typename T, typename... TRest> struct TMaxSizeof< T, TRest... >


description: Sort the array.

code: template<class T, class PREDICATE_CLASS> static void Sort ( T * First, const int32 Num, const PREDICATE_CLASS & Predicate )


className: TMergeSort

description: TMergePolicy Merging policy.  MinMergeSubgroupSize Minimal size of the subgroup that should be merged.

code: template<class TMergePolicy, int32 MinMergeSubgroupSize> class TMergeSort


className: TModels

description: Traits class which does concept checking.

code: template<typename Concept, typename... Args> struct TModels


className: Copy

description: Param type is not an const lvalue reference, which means it's pass-by-value, so we should just provide a single type for copying. Move overloads will be ignored due to SFINAE.

code: typedef U Copy


className: TMoveSupportTraitsBase

description: TMoveSupportTraitsBase< T, const T & >

code: template<typename T, typename U> struct TMoveSupportTraitsBase


description: Param type is a const lvalue reference, so we can provide an overload for moving.

code: typedef const T & Copy


className: TMoveSupportTraitsBase< T, const T & >

code: template<typename T> struct TMoveSupportTraitsBase< T, const T & >


code: static constexpr bool Value = TModels_V<Concept, Args...>;


className: TNameOf

code: template<typename T> struct TNameOf


className: TNameOf< double >::GetName

code: static TCHAR const &42; GetName&40;&41;


className: TNameOf< float >::GetName


className: TNameOf< double >

code: template<> struct TNameOf< double >


className: TNameOf< float >

code: template<> struct TNameOf< float >


className: TNameOf< int16 >::GetName


className: TNameOf< int16 >

code: template<> struct TNameOf< int16 >


className: TNameOf< int32 >

code: template<> struct TNameOf< int32 >


className: TNameOf< int32 >::GetName


className: TNameOf< int64 >::GetName


className: TNameOf< int64 >

code: template<> struct TNameOf< int64 >


className: TNameOf< int8 >::GetName


className: TNameOf< int8 >

code: template<> struct TNameOf< int8 >


className: TNameOf< uint32 >::GetName


className: TNameOf< uint16 >::GetName


className: TNameOf< uint16 >

code: template<> struct TNameOf< uint16 >


className: TNameOf< uint32 >

code: template<> struct TNameOf< uint32 >


className: TNameOf< uint64 >::GetName


className: TNameOf< uint64 >

code: template<> struct TNameOf< uint64 >


className: TNameOf< uint8 >::GetName


className: TNameOf< uint8 >

code: template<> struct TNameOf< uint8 >


description: Returns the internal pointer

code: ObjectType * Get() const


description: Arrow operator returns a pointer to this pointer's object

code: ObjectType * operator->() const


className: TNonNullPtr::operator ObjectType *

description: Returns the internal pointer

code: operator ObjectType *() const


description: Assignment operator taking a nullptr - not allowed.

code: [TNonNullPtr](API\Runtime\Core\Templates\TNonNullPtr) & operator= ( TYPE_OF_NULLPTR )


description: Assignment operator taking a pointer

code: [TNonNullPtr](API\Runtime\Core\Templates\TNonNullPtr) & operator= ( ObjectType * InObject )


description: Assignment operator taking anotherTNonNullPtr

code: template<typename OtherObjectType> [TEnableIf](API\Runtime\Core\Templates\TEnableIf)< [UE::Core::Private::NonNullPtr::TPointerIsConvertibleFromTo](API\Runtime\Core\Templates\TPointerIsConvertibleFromTo)< OtherObjectType, ObjectType >::Value, [TNonNullPtr](API\Runtime\Core\Templates\TNonNullPtr) & >::Type operator= ( const [TNonNullPtr](API\Runtime\Core\Templates\TNonNullPtr)< OtherObjectType > & Other )


description: Dereference operator returns a reference to the object this pointer points to

code: ObjectType & operator*() const


description: Hack that can be used under extraordinary circumstances

code: TNonNullPtr ( EDefaultConstructNonNullPtr )


description: Constructs a non-null pointer from the provided pointer. Must not be nullptr.

code: TNonNullPtr ( ObjectType * InObject )


description: Nullptr constructor - not allowed.

code: TNonNullPtr ( TYPE_OF_NULLPTR )


description: Constructs a non-null pointer from another non-null pointer

code: template<typename OtherObjectType, typename> TNonNullPtr ( const [TNonNullPtr](API\Runtime\Core\Templates\TNonNullPtr)< OtherObjectType > & Other )


className: TNonNullPtr

description: TNonNullPtris a non-nullable, non-owning, raw/naked/unsafe pointer.

code: template<typename ObjectType> class TNonNullPtr


className: Value

code: static constexpr bool Value = !Type::Value;


className: value

code: static constexpr bool value = !Type::Value;


className: TNot

description: Does a boolean NOT of the Value static members of the type.

code: template<typename Type> struct TNot


className: TNthTypeFromParameterPack

description: TNthTypeFromParameterPack< 0, T, OtherTypes... >TNthTypeFromParameterPack< N, T, OtherTypes... >

code: template<typename A, typename B> struct TNthTypeFromParameterPack


code: template<typename T, typename... OtherTypes> struct TNthTypeFromParameterPack< 0, T, OtherTypes... >


className: Type

code: typedef typename TNthTypeFromParameterPack< N-1, OtherTypes... >::Type Type


code: template<int32 N, typename T, typename... OtherTypes> struct TNthTypeFromParameterPack< N, T, OtherTypes... >


description:
Overloaded dereference operator. Provides read-only access to the original value of the data being tracked by this struct
a const reference to the original data value

code: const AssignedType & operator*() const


code: TOptionalGuardValue ( RefType & ReferenceValue, const AssignedType & NewValue )


className: TOptionalGuardValue

description: Exception-safe guard around saving/restoring a value. Commonly used to make sure a value is restored even if the code early outs in the future. Usage: TOptionalGuardValueGuardSomeBool(bSomeBool, false); // Sets bSomeBool to false, and restores it in dtor.

code: template<typename RefType, typename AssignedType> struct TOptionalGuardValue : private [FNoncopyable](API\Runtime\Core\Templates\FNoncopyable)


className: TOr

description: TOr< LHS, RHS... >TOr<>

code: template<typename... Types> struct TOr


code: static constexpr bool Value = TOr<RHS...>::value;


className: TOrValue

description: TOrValue< true, RHS... >

code: template<bool LHSValue, typename... RHS> struct TOrValue


code: static constexpr bool value = TOr<RHS...>::value;


className: TOrValue< true, RHS... >

code: template<typename... RHS> struct TOrValue< true, RHS... >


className: EDeepCopyType

code: enum EDeepCopyType { ConstructType, }


className: TOr< LHS, RHS... >

code: template<typename LHS, typename... RHS> struct TOr< LHS, RHS... > : public [TOrValue< LHS::Value, RHS... >](API\Runtime\Core\Templates\TOrValue)


className: ENoCopyType

code: enum ENoCopyType { ConstructType, }


code: TPimplHeapObjectImpl ( void * InVal )


code: template<typename... ArgTypes> TPimplHeapObjectImpl ( [ENoCopyType](API\Runtime\Core\Templates\TPimplHeapObjectImpl\ENoCopyType), ArgTypes &&... Args )


code: template<typename... ArgTypes> TPimplHeapObjectImpl ( [EDeepCopyType](API\Runtime\Core\Templates\TPimplHeapObjectImpl\EDeepCopyType), ArgTypes &&... Args )


className: TPimplHeapObjectImpl

code: template<typename T> struct TPimplHeapObjectImpl

Copier

type: FCopyFunc

Deleter

type: FDeleteFunc


className: TPimplPtr

code: template<typename T, EPimplPtrMode Mode> struct TPimplPtr


className: TPimplPtr< T, EPimplPtrMode::DeepCopy >::operator=

code: TPimplPtr & operator&61; &40; const TPimplPtr & A &41;


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


code: TPimplPtr & operator&61; &40; TYPE_OF_NULLPTR A &41;


className: Super

code: typedef TPimplPtr< T, EPimplPtrMode::NoCopy > Super


className: TPimplPtr< T, EPimplPtrMode::DeepCopy >::TPimplPtr


code: TPimplPtr &40; const TPimplPtr & A &41;


code: TPimplPtr &40; TPimplPtr && &41;


code: TPimplPtr &40; TYPE_OF_NULLPTR &41;


className: TPimplPtr< T, EPimplPtrMode::DeepCopy >::~TPimplPtr


className: TPimplPtr< T, EPimplPtrMode::NoCopy >::Get


className: TPimplPtr< T, EPimplPtrMode::NoCopy >::IsValid

code: bool IsValid&40;&41; const


className: TPimplPtr< T, EPimplPtrMode::DeepCopy >

code: namespace TPimplPtr< T, EPimplPtrMode { template<typename T> struct TPimplPtr< T, EPimplPtrMode::DeepCopy > : private [TPimplPtr< T, EPimplPtrMode::NoCopy >](API\Runtime\Core\Templates\TPimplPtr_T_EPimplPtrMode__NoCop-) }


className: TPimplPtr< T, EPimplPtrMode::NoCopy >::operator->


className: TPimplPtr< T, EPimplPtrMode::NoCopy >::operator bool

code: operator bool&40;&41; const


className: TPimplPtr< T, EPimplPtrMode::NoCopy >::operator=

code: TPimplPtr & operator&61; &40; TPimplPtr && Other &41;


code: TPimplPtr & operator&61; &40; TYPE_OF_NULLPTR &41;


className: TPimplPtr< T, EPimplPtrMode::NoCopy >::operator==

code: bool operator&61;&61; &40; TYPE_OF_NULLPTR &41;


className: TPimplPtr< T, EPimplPtrMode::NoCopy >::operator!=

code: bool operator&33;&61; &40; TYPE_OF_NULLPTR &41;


className: TPimplPtr< T, EPimplPtrMode::NoCopy >::operator*

code: T & operator&42;&40;&41; const


className: TPimplPtr< T, EPimplPtrMode::NoCopy >::Reset

code: void Reset&40;&41;


className: TPimplPtr< T, EPimplPtrMode::NoCopy >::TPimplPtr


code: TPimplPtr &40; UE::Core::Private::PimplPtr::TPimplHeapObjectImpl< T > &42; Impl &41;


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


code: TPimplPtr &40; const TPimplPtr & &41;


description: Movable.

code: TPimplPtr &40; TPimplPtr && Other &41;


className: TPimplPtr< T, EPimplPtrMode::NoCopy >::~TPimplPtr


className: TPimplPtr< T, EPimplPtrMode::NoCopy >

code: namespace TPimplPtr< T, EPimplPtrMode { template<typename T> struct TPimplPtr< T, EPimplPtrMode::NoCopy > }


description: Specialization of `UE::Core::Private::NonNullPtr::TPointerIsConvertibleFromTo_ for function types, which are always complete types

code: template<typename Result1, typename... Args1, typename Result2, typename... Args2> struct TPointerIsConvertibleFromTo< Result1(Args1...), Result2(Args2...)> : public [TPointerIsConvertibleFromTo< Result1(Args1...), Result2(Args2...)>](API\Runtime\Core\Templates\TPointerIsConvertibleFromTo_1)


className: TPointerIsConvertibleFromTo

description: TPointerIsConvertibleFromTo< Result1(Args1...), Result2(Args2...)>

code: template<typename, typename, typename> struct TPointerIsConvertibleFromTo


description: Tests if a From* is convertible to a To*

code: template<typename From, typename To> struct TPointerIsConvertibleFromTo : public [UE::Core::Private::PointerIsConvertibleFromTo::TImpl< From, To >](API\Runtime\Core\Templates\TImpl)


code: class TPointerIsConvertibleFromTo_TestDerived : public [TPointerIsConvertibleFromTo_TestBase](API\Runtime\Core\Templates\TPointerIsConvertibleFromTo_Test-)


code: uint32 operator() ( const T & Value ) const


code: template<typename T> struct TRadixSortKeyCastUint32


description: Construct implicitly from a nullptr

code: TRawPtrProxy ( TYPE_OF_NULLPTR )


description: Construct explicitly from an object

code: TRawPtrProxy ( ObjectType * InObject )


description: Construct implicitly from an object and a custom deleter

code: TRawPtrProxyWithDeleter ( ObjectType * InObject, const DeleterType & InDeleter )


code: TRawPtrProxyWithDeleter ( ObjectType * InObject, DeleterType && InDeleter )


className: TRawPtrProxyWithDeleter

description: Proxy structure for implicitly converting raw pointers to shared/weak pointers

code: template<class ObjectType, typename DeleterType> struct TRawPtrProxyWithDeleter

type: DeleterType

description: The deleter object

Object

type: ObjectType *...

description: The object pointer


code: ReferencedType ** GetInitReference()


className: TRawPtrProxy

code: template<class ObjectType> struct TRawPtrProxy

description: The object pointer


code: ReferencedType * GetReference() const


className: TRefCountPtr::operator ReferenceType

code: operator ReferenceType() const


code: [TRefCountPtr](API\Runtime\Core\Templates\TRefCountPtr) & operator= ( ReferencedType * InReference )


code: [TRefCountPtr](API\Runtime\Core\Templates\TRefCountPtr) & operator= ( const [TRefCountPtr](API\Runtime\Core\Templates\TRefCountPtr) & InPtr )


code: template<typename CopyReferencedType> [TRefCountPtr](API\Runtime\Core\Templates\TRefCountPtr) & operator= ( const [TRefCountPtr](API\Runtime\Core\Templates\TRefCountPtr)< CopyReferencedType > & InPtr )


code: [TRefCountPtr](API\Runtime\Core\Templates\TRefCountPtr) & operator= ( [TRefCountPtr](API\Runtime\Core\Templates\TRefCountPtr) && InPtr )


code: template<typename MoveReferencedType> [TRefCountPtr](API\Runtime\Core\Templates\TRefCountPtr) & operator= ( [TRefCountPtr](API\Runtime\Core\Templates\TRefCountPtr)< MoveReferencedType > && InPtr )


code: bool operator== ( const [TRefCountPtr](API\Runtime\Core\Templates\TRefCountPtr) & B ) const


code: bool operator== ( ReferencedType * B ) const


className: ReferenceType

code: typedef ReferencedType * ReferenceType


code: void Serialize ( [FArchive](API\Runtime\Core\Serialization\FArchive) & Ar )


code: void Swap ( [TRefCountPtr](API\Runtime\Core\Templates\TRefCountPtr) & InPtr )


code: TRefCountPtr ( const [TRefCountPtr](API\Runtime\Core\Templates\TRefCountPtr) & Copy )


code: TRefCountPtr ( [TRefCountPtr](API\Runtime\Core\Templates\TRefCountPtr) && Move )


code: template<typename CopyReferencedType> TRefCountPtr ( const [TRefCountPtr](API\Runtime\Core\Templates\TRefCountPtr)< CopyReferencedType > & Copy )


code: template<typename MoveReferencedType> TRefCountPtr ( [TRefCountPtr](API\Runtime\Core\Templates\TRefCountPtr)< MoveReferencedType > && Move )


code: TRefCountPtr ( ReferencedType * InReference, bool bAddRef )


className: TRefCountPtr

description: A smart pointer to an object which implements AddRef/Release.

code: template<typename ReferencedType> class TRefCountPtr


description: Adds a shared reference to this counter

code: void AddSharedReference()


description: Adds a weak reference to this counter

code: void AddWeakReference()


description:
Adds a shared reference to this counter ONLY if there is already at least one reference
True if the shared reference was added successfully

code: bool ConditionallyAddSharedReference()


description: Destroys the object associated with this reference counter.

code: void DestroyObject()


description: Returns the shared reference count

code: int32 GetSharedReferenceCount() const


description: Checks if there is exactly one reference left to the object.

code: bool IsUnique() const


code: [TReferenceControllerBase](API\Runtime\Core\Templates\TReferenceControllerBase) & operator= ( const [TReferenceControllerBase](API\Runtime\Core\Templates\TReferenceControllerBase) & )