code: namespace Algo { template<typename RangeType, typename ProjectionType> auto Algo::MinElementBy ( RangeType & Range, ProjectionType Proj ) }


description:
Returns a pointer to the minimum element in a range with a user-defined binary comparator. If the range contains multiple minimum elements, a pointer to the first one will be returned.
A pointer to the minimum element, or nullptr if the range was empty.

module: Core

code: namespace Algo { template<typename RangeType, typename ProjectionType, typename ComparatorType> auto Algo::MinElementBy ( RangeType & Range, ProjectionType Proj, ComparatorType Comp ) }


description:
Checks if no element in the range is truthy.
true if no element is truthy, false otherwise.

code: namespace Algo { template<typename RangeType> bool Algo::NoneOf ( const RangeType & Range ) }


description:
Checks if no projection of the elements in the range is truthy.
true if none of the projections are truthy, false otherwise.

code: namespace Algo { template<typename RangeType, typename ProjectionType> bool Algo::NoneOf ( const RangeType & Range, ProjectionType Projection ) }


description:
Checks if no projection of the elements in the range is truthy. Should be used when the range iterator doesn't return a reference.
true if none of the projections are truthy, false otherwise.

code: namespace Algo { template<typename RangeType, typename ProjectionType> bool Algo::NoneOf ( const RangeType & Range, ProjectionType Projection, [ENoRef](API\Runtime\Core\Algo\Algo__ENoRef) NoRef ) }


code: namespace Algo { [ETopologicalSort](API\Runtime\Core\Algo\Algo__ETopologicalSort) & Algo::operator|= ( [ETopologicalSort](API\Runtime\Core\Algo\Algo__ETopologicalSort) & Lhs, [ETopologicalSort](API\Runtime\Core\Algo\Algo__ETopologicalSort) Rhs ) }


code: namespace Algo { [ETopologicalSort](API\Runtime\Core\Algo\Algo__ETopologicalSort) & Algo::operator&= ( [ETopologicalSort](API\Runtime\Core\Algo\Algo__ETopologicalSort) & Lhs, [ETopologicalSort](API\Runtime\Core\Algo\Algo__ETopologicalSort) Rhs ) }


code: namespace Algo { [ETopologicalSort](API\Runtime\Core\Algo\Algo__ETopologicalSort) & Algo::operator^= ( [ETopologicalSort](API\Runtime\Core\Algo\Algo__ETopologicalSort) & Lhs, [ETopologicalSort](API\Runtime\Core\Algo\Algo__ETopologicalSort) Rhs ) }


code: namespace Algo { constexpr [ETopologicalSort](API\Runtime\Core\Algo\Algo__ETopologicalSort) Algo::operator| ( [ETopologicalSort](API\Runtime\Core\Algo\Algo__ETopologicalSort) Lhs, [ETopologicalSort](API\Runtime\Core\Algo\Algo__ETopologicalSort) Rhs ) }


code: namespace Algo { constexpr [ETopologicalSort](API\Runtime\Core\Algo\Algo__ETopologicalSort) Algo::operator& ( [ETopologicalSort](API\Runtime\Core\Algo\Algo__ETopologicalSort) Lhs, [ETopologicalSort](API\Runtime\Core\Algo\Algo__ETopologicalSort) Rhs ) }


code: namespace Algo { constexpr [ETopologicalSort](API\Runtime\Core\Algo\Algo__ETopologicalSort) Algo::operator^ ( [ETopologicalSort](API\Runtime\Core\Algo\Algo__ETopologicalSort) Lhs, [ETopologicalSort](API\Runtime\Core\Algo\Algo__ETopologicalSort) Rhs ) }


code: namespace Algo { constexpr bool Algo::operator! ( [ETopologicalSort](API\Runtime\Core\Algo\Algo__ETopologicalSort) E ) }


code: namespace Algo { constexpr [ETopologicalSort](API\Runtime\Core\Algo\Algo__ETopologicalSort) Algo::operator~ ( [ETopologicalSort](API\Runtime\Core\Algo\Algo__ETopologicalSort) E ) }


description:
Rearranges the elements so that all the elements for which Predicate returns true precede all those for which it returns false. (not stable)
index of the first element in the second group

code: namespace Algo { template<typename RangeType, typename UnaryPredicateType> auto Algo::Partition ( RangeType && Range, UnaryPredicateType Predicate ) }


code: namespace Algo { template<class T, typename IndexType, typename UnaryPredicate> IndexType Algo::Partition ( T * Elements, const IndexType Num, UnaryPredicate Predicate ) }


code: namespace Algo { namespace Private { template<typename InAT, typename InBT, typename ProjectionT, typename PredicateT> constexpr bool Algo::Private::Compare ( InAT && InputA, InBT && InputB, ProjectionT Projection, PredicateT Predicate ) } }


code: namespace Algo { namespace Private { template<typename DataTypeA, typename SizeTypeA, typename DataTypeB, typename SizeTypeB, typename ProjectionType, typename SortPredicateType> constexpr bool Algo::Private::Includes ( const DataTypeA * DataA, SizeTypeA NumA, const DataTypeB * DataB, SizeTypeB NumB, ProjectionType Projection, SortPredicateType SortPredicate ) } }


description: Randomly shuffle a range of elements.

code: namespace Algo { template<typename RangeType> void Algo::RandomShuffle ( RangeType & Range ) }


description:
Moves all elements which do not match the predicate to the front of the range, while leaving all other elements is a constructed but unspecified state. The elements which were not removed are not guaranteed to be kept in order (unstable).
The index of the first element after those which were not removed.

code: namespace Algo { template<typename RangeType, typename Predicate> int32 Algo::RemoveIf ( RangeType & Range, Predicate Pred ) }


description: Replaces all elements that satisfy the predicate with the given value.

code: namespace Algo { template<typename RangeType, typename ValueType, typename PredicateType> void Algo::ReplaceIf ( RangeType && Range, PredicateType InPred, const ValueType & InNew ) }


description: Replaces all elements that compare equal to one value with a new value.

code: namespace Algo { template<typename RangeType, typename ValueType> void Algo::Replace ( RangeType && Range, const ValueType & InOld, const ValueType & InNew ) }


description: Reverses a range

code: namespace Algo { template<typename T, int32 ArraySize> void Algo::Reverse ( T(&) Array ) }


description: Reverses a range

code: namespace Algo { template<typename ContainerType> void Algo::Reverse ( ContainerType & Container ) }


description: Reverses a range

code: namespace Algo { template<typename T> void Algo::Reverse ( T * Array, int32 ArraySize ) }


description: Randomly select an element from a range of elements, weighted by a projection. The chance of any element being chosen is its weight / the sum of all the weights in the range. Negative- or zero- weighted elements will not be chosen or count toward the total.

code: namespace Algo { template<typename RangeType, typename ProjectionType> auto Algo::SelectRandomWeightedBy ( RangeType && Range, ProjectionType Proj ) }


description:
Rotates a given amount of elements from the front of the range to the end of the range.
The new index of the element that was previously at the start of the range.

code: namespace Algo { template<typename RangeType> int32 Algo::Rotate ( RangeType & Range, int32 Count ) }


description: Sort a range of elements using its operator<. The sort is unstable.

code: namespace Algo { template<typename RangeType> void Algo::Sort ( RangeType && Range ) }


description: Sort a range of elements using a user-defined predicate class. The sort is unstable.

code: namespace Algo { template<typename RangeType, typename PredicateType> void Algo::Sort ( RangeType && Range, PredicateType Pred ) }


description: Sort a range of elements by a projection using the projection's operator<. The sort is unstable.

code: namespace Algo { template<typename RangeType, typename ProjectionType> void Algo::SortBy ( RangeType && Range, ProjectionType Proj ) }


description: Sort a range of elements by a projection using a user-defined predicate class. The sort is unstable.

code: namespace Algo { template<typename RangeType, typename ProjectionType, typename PredicateType> void Algo::SortBy ( RangeType && Range, ProjectionType Proj, PredicateType Pred ) }


description:
Moves all elements which do not match the predicate to the front of the range, while leaving all other elements is a constructed but unspecified state. The elements which were not removed are guaranteed to be kept in order (stable).
The index of the first element after those which were not removed.

code: namespace Algo { template<typename RangeType, typename Predicate> int32 Algo::StableRemoveIf ( RangeType & Range, Predicate Pred ) }


description: Sort a range of elements using its operator<. The sort is stable.

code: namespace Algo { template<typename RangeType> void Algo::StableSort ( RangeType && Range ) }


description: Sort a range of elements using a user-defined predicate class. The sort is stable.

code: namespace Algo { template<typename RangeType, typename PredicateType> void Algo::StableSort ( RangeType && Range, PredicateType Pred ) }


description: Sort a range of elements by a projection using the projection's operator<. The sort is stable.

code: namespace Algo { template<typename RangeType, typename ProjectionType> void Algo::StableSortBy ( RangeType && Range, ProjectionType Proj ) }


description: Sort a range of elements by a projection using a user-defined predicate class. The sort is stable.

code: namespace Algo { template<typename RangeType, typename ProjectionType, typename PredicateType> void Algo::StableSortBy ( RangeType && Range, ProjectionType Proj, PredicateType Pred ) }


description:
Example:TArrayOut1;TArrayOut2; TieTupleAdd(Out1, Out2).Add(MakeTuple(42, TEXT("42"))); // Out1 = { 42 }, Out2 = { "42" }
An object with an Add function that will call Add on the tied elements

code: namespace Algo { template<typename... OutputTypes> [Private::TTiedTupleAdder](API\Runtime\Core\Algo\TTiedTupleAdder)< OutputTypes... > Algo::TieTupleAdd ( OutputTypes &... Outputs ) }


description: Applies a transform to a range and stores the results into a container

code: namespace Algo { template<typename InT, typename OutT, typename TransformT> void Algo::Transform ( const InT & Input, OutT && Output, TransformT Trans ) }


description:
Sums a range by applying MapOp to each element, and then summing the results.
the result of mapping and then summing all the elements of Input

code: namespace Algo { template<typename T, typename A, typename MapT> T Algo::TransformAccumulate ( const A & Input, MapT MapOp, T Init ) }


code: namespace Algo { template<typename T, typename A, typename MapT, typename OpT> T Algo::TransformAccumulate ( const A & Input, MapT MapOp, T Init, OpT Op ) }


description: Conditionally applies a transform to a range and stores the results into a container

code: namespace Algo { template<typename InT, typename OutT, typename PredicateT, typename TransformT> void Algo::TransformIf ( const InT & Input, OutT && Output, PredicateT Predicate, TransformT Trans ) }


code: namespace Algo { template<typename RangeType, typename ValueType> auto Algo::UpperBound ( RangeType & Range, const ValueType & Value ) }


code: namespace Algo { template<typename RangeType, typename ValueType, typename SortPredicateType> auto Algo::UpperBound ( RangeType & Range, const ValueType & Value, SortPredicateType SortPredicate ) }


code: namespace Algo { template<typename RangeType, typename ValueType, typename ProjectionType> auto Algo::UpperBoundBy ( RangeType & Range, const ValueType & Value, ProjectionType Projection ) }


code: namespace Algo { template<typename RangeType, typename ValueType, typename ProjectionType, typename SortPredicateType> auto Algo::UpperBoundBy ( RangeType & Range, const ValueType & Value, ProjectionType Projection, SortPredicateType SortPredicate ) }


className: FKahnContext

description: Some variables shared with subfunctions

code: struct FKahnContext

Dependencies

type: TArray<TArray<...

DependencyCount

type: TArray< int32 >

MRVSContext

type: TOptional<FMut...

RemainingVertices

type: TSet<FKahnHand...


className: FKahnHandle

description: KahnTopologicalSort converts vertices and edges from ElementType to indexes of the vertex in the original UniqueRange of ElementType. FKahnHandle is how vertices are represented during the graph algorithm

code: typedef int32 FKahnHandle


className: FMutuallyReachableVertexSetContext

description: Scratch variables shared across multiple calls to FindMostIndependentMutuallyReachableVertexSet

Cycle

type: TArray<FKahnHa...


description: Gets the index of the left child of node atIndex.Indexof the left child.

code: namespace AlgoImpl { template<typename IndexType> IndexType AlgoImpl::HeapGetLeftChildIndex ( IndexType Index ) }


description:
Gets the parent index for node atIndex.
Parent index.

code: namespace AlgoImpl { template<typename IndexType> IndexType AlgoImpl::HeapGetParentIndex ( IndexType Index ) }


description: Builds an implicit min-heap from a range of elements. This is the internal function used by Heapify overrides.

code: namespace AlgoImpl { template<typename RangeValueType, typename IndexType, typename ProjectionType, typename PredicateType> void AlgoImpl::HeapifyInternal ( RangeValueType * First, IndexType Num, ProjectionType Projection, PredicateType Predicate ) }


description:
Checks if node located atIndexis a leaf or not.
true if node is a leaf, false otherwise.

code: namespace AlgoImpl { template<typename IndexType> bool AlgoImpl::HeapIsLeaf ( IndexType Index, IndexType Count ) }


description: Performs heap sort on the elements. This is the internal sorting function used by HeapSort overrides.

code: namespace AlgoImpl { template<typename RangeValueType, typename IndexType, typename ProjectionType, class PredicateType> void AlgoImpl::HeapSortInternal ( RangeValueType * First, IndexType Num, ProjectionType Projection, PredicateType Predicate ) }


description:
Fixes a possible violation of order property between node at NodeIndex and a parent.
The new index of the node that was at NodeIndex

code: namespace AlgoImpl { template<class RangeValueType, typename IndexType, typename ProjectionType, class PredicateType> IndexType AlgoImpl::HeapSiftUp ( RangeValueType * Heap, IndexType RootIndex, IndexType NodeIndex, const ProjectionType & Projection, const PredicateType & Predicate ) }


description: Fixes a possible violation of order property between node atIndexand a child.

code: namespace AlgoImpl { template<typename RangeValueType, typename IndexType, typename ProjectionType, typename PredicateType> void AlgoImpl::HeapSiftDown ( RangeValueType * Heap, IndexType Index, const IndexType Count, const ProjectionType & Projection, const PredicateType & Predicate ) }


className: Type

code: typedef decltype(&*DeclVal< RangeType & >().begin()) Type


className: TRangePointerType

description: TRangePointerType< T[N]>

code: template<typename RangeType> struct TRangePointerType


className: TRangePointerType< T[N]>

code: template<typename T, unsigned int N> struct TRangePointerType< T[N]>


code: bool operator() ( const T & Lhs, const T & Rhs ) const


className: TLess

description: TLess< void >

code: template<typename T> struct TLess


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


className: TPlus

description: TPlus< void >

code: template<typename T> struct TPlus


className: TPlus< void >::operator()

code: template<typename U, typename V> auto operator&40;&41; &40; U && A, V && B &41;


className: TPlus< void >

code: template<> struct TPlus< void >


code: template<typename TupleType> void Add ( TupleType && Values )


className: TTiedTupleAdder

code: template<typename... OutputTypes> struct TTiedTupleAdder

Outputs

type: TTuple< OutputT...


code: namespace ENamedThreads { int32 ENamedThreads::GetQueueIndex ( [Type](API\Runtime\Core\Async\ENamedThreads__Type) ThreadAndIndex ) }


code: namespace ENamedThreads { [Type](API\Runtime\Core\Async\ENamedThreads__Type) ENamedThreads::GetRenderThread() }


code: namespace ENamedThreads { [Type](API\Runtime\Core\Async\ENamedThreads__Type) ENamedThreads::GetRenderThread_Local() }


code: namespace ENamedThreads { int32 ENamedThreads::GetTaskPriority ( [Type](API\Runtime\Core\Async\ENamedThreads__Type) ThreadAndIndex ) }


code: namespace ENamedThreads { [Type](API\Runtime\Core\Async\ENamedThreads__Type) ENamedThreads::GetThreadIndex ( [Type](API\Runtime\Core\Async\ENamedThreads__Type) ThreadAndIndex ) }


code: namespace ENamedThreads { int32 ENamedThreads::GetThreadPriorityIndex ( [Type](API\Runtime\Core\Async\ENamedThreads__Type) ThreadAndIndex ) }


code: namespace ENamedThreads { [Type](API\Runtime\Core\Async\ENamedThreads__Type) ENamedThreads::SetPriorities ( [Type](API\Runtime\Core\Async\ENamedThreads__Type) ThreadAndIndex, [Type](API\Runtime\Core\Async\ENamedThreads__Type) ThreadPriority, [Type](API\Runtime\Core\Async\ENamedThreads__Type) TaskPriority ) }


code: namespace ENamedThreads { [Type](API\Runtime\Core\Async\ENamedThreads__Type) ENamedThreads::SetPriorities ( [Type](API\Runtime\Core\Async\ENamedThreads__Type) ThreadAndIndex, int32 PriorityIndex, bool bHiPri ) }


code: namespace ENamedThreads { void ENamedThreads::SetRenderThread ( [Type](API\Runtime\Core\Async\ENamedThreads__Type) Thread ) }


code: namespace ENamedThreads { void ENamedThreads::SetRenderThread_Local ( [Type](API\Runtime\Core\Async\ENamedThreads__Type) Thread ) }


code: namespace ENamedThreads { [Type](API\Runtime\Core\Async\ENamedThreads__Type) ENamedThreads::SetTaskPriority ( [Type](API\Runtime\Core\Async\ENamedThreads__Type) ThreadAndIndex, [Type](API\Runtime\Core\Async\ENamedThreads__Type) TaskPriority ) }


code: namespace ENamedThreads { [Type](API\Runtime\Core\Async\ENamedThreads__Type) ENamedThreads::SetThreadPriority ( [Type](API\Runtime\Core\Async\ENamedThreads__Type) ThreadAndIndex, [Type](API\Runtime\Core\Async\ENamedThreads__Type) ThreadPriority ) }


description: Forward declaration for ENamedThreads

code: namespace ENamedThreads { enum Type { UnusedAnchor = -1, RHIThread, GameThread, ActualRenderingThread = GameThread + 1, AnyThread = 0xff, MainQueue = 0x000, LocalQueue = 0x100, NumQueues = 2, ThreadIndexMask = 0xff, QueueIndexMask = 0x100, QueueIndexShift = 8, NormalTaskPriority = 0x000, HighTaskPriority = 0x200, NumTaskPriorities = 2, TaskPriorityMask = 0x200, TaskPriorityShift = 9, NormalThreadPriority = 0x000, HighThreadPriority = 0x400, BackgroundThreadPriority = 0x800, NumThreadPriorities = 3, ThreadPriorityMask = 0xC00, ThreadPriorityShift = 10, GameThread_Local = GameThread | LocalQueue, ActualRenderingThread_Local = ActualRenderingThread | LocalQueue, AnyHiPriThreadNormalTask = AnyThread | HighThreadPriority | NormalTaskPriority, AnyHiPriThreadHiPriTask = AnyThread | HighThreadPriority | HighTaskPriority, AnyNormalThreadNormalTask = AnyThread | NormalThreadPriority | NormalTaskPriority, AnyNormalThreadHiPriTask = AnyThread | NormalThreadPriority | HighTaskPriority, AnyBackgroundThreadNormalTask = AnyThread | BackgroundThreadPriority | NormalTaskPriority, AnyBackgroundHiPriTask = AnyThread | BackgroundThreadPriority | HighTaskPriority, } }


code: namespace ESubsequentsMode { enum Type { TrackSubsequents, FireAndForget, } }


description:
Gets the task's stats tracking identifier.
Stats identifier.


description:
Gets the mode for tracking subsequent tasks.
Always track subsequent tasks.


className: FAsyncGraphTaskBase

description: Base class for asynchronous functions that are executed in the Task Graph system.

code: class FAsyncGraphTaskBase


description:
Submit an async request and/or wait for an async request
A request for the read. This is owned by the caller and must be deleted by the caller.

code: virtual [IAsyncReadRequest](API\Runtime\Core\Async\IAsyncReadRequest) * ReadRequest ( int64 Offset, int64 BytesToRead, EAsyncIOPriorityAndFlags PriorityAndFlags, FAsyncFileCallBack * CompleteCallback, uint8 * UserSuppliedMemory )


description: Return true if this file is backed by a cache, if not, then precache requests are ignored.

code: virtual bool UsesCache()


className: FAsyncReadFileHandleNull

description: AnIAsyncReadFileHandlethat returns only failed results, used when a function has failed but needs to return a non-nullIAsyncReadFileHandle.

code: class FAsyncReadFileHandleNull : public [IAsyncReadFileHandle](API\Runtime\Core\Async\IAsyncReadFileHandle)


description: Cancel the request. This is a non-blocking async call and so does not ensure completion!

code: virtual void CancelImpl()


description: Transfer ownership of Memory from the async request to the outside caller (called in response to GetReadResults). It's only relevant to Read requests, in which case the most common use is to update (decrease) the STAT_AsyncFileMemory stat which is typically incremented when async requests allocate Memory. It doesn't play any role in Size requests, so it may be left empty for them.


description:
Waits for the request to complete, but not longer than the given time limit
true if the request is complete

code: virtual void WaitCompletionImpl ( float TimeLimitSeconds )


code: FAsyncReadRequestNull ( FAsyncFileCallBack * InCallback, bool bInSizeRequest )


className: FAsyncReadRequestNull

description: IAsyncReadRequestreturned fromFAsyncReadFileHandleNull; guaranteed to be a cancelled readrequest with no size or bytes when the Callback is called.

code: class FAsyncReadRequestNull : public [IAsyncReadRequest](API\Runtime\Core\Async\IAsyncReadRequest)


description: Perform task's work

code: virtual void DoTaskWork()


description:
Retrieve embedded user job, not legal to call while a job is in process
reference to embedded user job

code: TTask & GetTask()


description:
Request the size of the file. This is also essentially the existence check.
A request for the size. This is owned by the caller and must be deleted by the caller.

code: virtual [IAsyncReadRequest](API\Runtime\Core\Async\IAsyncReadRequest) * SizeRequest ( FAsyncFileCallBack * CompleteCallback )


code: const TTask & GetTask() const


description: Abandon task if possible, returns true on success, false otherwise.

code: virtual bool TryAbandonTask()


description: Forwarding constructor.

code: template<typename Arg0Type, typename... ArgTypes> FAsyncTask ( Arg0Type && Arg0, ArgTypes &&... Args )


className: FAsyncTask

description: Insights.

code: template<typename TTask> class FAsyncTask : public [FAsyncTaskBase](API\Runtime\Core\Async\FAsyncTaskBase)


description:
Cancel the task, if possible. Note that this is different than abandoning (which is called by the thread pool at shutdown).
true if the task was canceled and is safe to delete. If it wasn't canceled, it may be done, but that isn't checked here.

code: bool Cancel()


description: Internal call to assert that we are idle

code: void CheckIdle() const


description: Perform task's work

code: void DoTaskWork()


description: Wait until the job is complete

code: void EnsureCompletion ( bool bDoWorkOnThisThreadIfNotStarted, bool bIsLatencySensitive )


description: Returns text to identify the Work, for debug/log purposes only

code: virtual const TCHAR * GetDebugName() const


code: EQueuedWorkPriority GetPriority() const


description: Returns an approximation of the peak memory (in bytes) this task could require during it's execution.

code: virtual int64 GetRequiredMemory() const


code: void Init ( [TStatId](API\Runtime\Core\Stats\TStatId) InStatId )


description: Returns true if the work and TASK has completed, false while it's still in progress. prior to returning true, it synchronizes so the task can be destroyed or reused

code: bool IsDone()


description: Returns true if the work has not been started or has been completed. NOT to be used for synchronization, but great for check()'s

code: bool IsIdle() const


description: Returns true if the work has completed, false while it's still in progress. This does not block and if true, you can use the results. But you can't destroy or reuse the task withoutIsDone()being true orEnsureCompletion()

code: bool IsWorkDone() const


description:
If not already being processed, will be rescheduled on given thread pool and priority.
true if the reschedule was successful, false if was already being processed.

code: bool Reschedule ( [FQueuedThreadPool](API\Runtime\Core\Misc\FQueuedThreadPool) * InQueuedPool, EQueuedWorkPriority InQueuedWorkPriority )


code: bool SetPriority ( EQueuedWorkPriority QueuedWorkPriority )


description: Queue this task for processing by the background thread pool

code: void StartBackgroundTask ( [FQueuedThreadPool](API\Runtime\Core\Misc\FQueuedThreadPool) * InQueuedPool, EQueuedWorkPriority InQueuedWorkPriority, EQueuedWorkFlags InQueuedWorkFlags, int64 InRequiredMemory, const TCHAR * InDebugName )


description: Run this task on this thread

code: void StartSynchronousTask ( EQueuedWorkPriority InQueuedWorkPriority, EQueuedWorkFlags InQueuedWorkFlags, int64 InRequiredMemory, const TCHAR * InDebugName )


description:
Wait until the job is complete, up to a time limit
true if the task is completed

code: bool WaitCompletionWithTimeout ( float TimeLimitSeconds )


code: bool TryAbandonTask()


className: FAsyncTaskBase

description:
/Spinning on IsDone is not acceptable( see EnsureCompletion ), but it is ok to check once a frame. /Ensure the task is done, doing the task on the current thread if it has not been started, waiting until completion in all cases.     MyTask->EnsureCompletion();
    delete Task;
}

code: class FAsyncTaskBase : private [UE::FInheritedContextBase](API\Runtime\Core\Async\FInheritedContextBase), private [IQueuedWork](API\Runtime\Core\Misc\IQueuedWork)


className: FAsyncThreadIndex

description: Helper struct used to generate unique ids for the stats.

code: struct FAsyncThreadIndex


code: [ENamedThreads::Type](API\Runtime\Core\Async\ENamedThreads__Type) Get ( [ENamedThreads::Type](API\Runtime\Core\Async\ENamedThreads__Type) Thread )


code: FAutoConsoleTaskPriority ( const TCHAR * Name, const TCHAR * Help, [ENamedThreads::Type](API\Runtime\Core\Async\ENamedThreads__Type) DefaultThreadPriority, [ENamedThreads::Type](API\Runtime\Core\Async\ENamedThreads__Type) DefaultTaskPriority, [ENamedThreads::Type](API\Runtime\Core\Async\ENamedThreads__Type) DefaultTaskPriorityIfForcedToNormalThreadPriority )


description: Destructor, not legal when a task is in process

code: virtual ~FAsyncTaskBase()


className: FAutoConsoleTaskPriority

description: Deprecated* No longer supported

code: class FAutoConsoleTaskPriority


description: Run this task on the lo priority thread pool. It is not safe to use this object after this call.

code: void StartBackgroundTask ( [FQueuedThreadPool](API\Runtime\Core\Misc\FQueuedThreadPool) * InQueuedPool, EQueuedWorkPriority InPriority )


description: Run this task on this thread, now. Will end up destroying myself, so it is not safe to use this object after this call.

code: void StartSynchronousTask()


description: Forwarding constructor.

code: template<typename... T> FAutoDeleteAsyncTask ( T &&... Args )


className: FAutoDeleteAsyncTask

description: / do an example job now, on this thread (new FAutoDeleteAsyncTask(5)->StartSynchronousTask(); }

code: template<typename TTask> class FAutoDeleteAsyncTask : private [UE::FInheritedContextBase](API\Runtime\Core\Async\FInheritedContextBase), private [IQueuedWork](API\Runtime\Core\Misc\IQueuedWork)


className: ELifeStage

description: Life stage verification Tasks go through 8 steps, in order. In non-final builds, we track them with a thread safe counter and verify that the progression is correct.

code: enum ELifeStage { LS_BaseContructed = 0, LS_Contructed, LS_ThreadSet, LS_PrequisitesSetup, LS_Queued, LS_Executing, LS_Deconstucted, }


description: An indication that a prerequisite has been completed. Reduces the number of prerequisites by one and if no prerequisites are outstanding, it queues the task for execution.

code: void ConditionalQueueTask ( [ENamedThreads::Type](API\Runtime\Core\Async\ENamedThreads__Type) CurrentThread, bool & bWakeUpWorker )


description: Indicates that the prerequisites are set up and that the task can be executed as soon as the prerequisites are finished.

code: void PrerequisitesComplete ( [ENamedThreads::Type](API\Runtime\Core\Async\ENamedThreads__Type) CurrentThread, int32 NumAlreadyFinishedPrequistes, bool bUnlock )


description: Logs a task name that may contain invalid subsequents. Debug only.

code: static void LogPossiblyInvalidSubsequentsTask ( const TCHAR * TaskName )


description: Sets the desired execution thread. This is not part of the constructor because this information may not be known quite yet duiring construction.

code: void SetThreadToExecuteOn ( [ENamedThreads::Type](API\Runtime\Core\Async\ENamedThreads__Type) InThreadToExecuteOn )


code: void SetTraceId ( [TaskTrace::FId](API\Runtime\Core\Async\FId) InTraceId )


description: Constructor

code: FBaseGraphTask ( int32 InNumberOfPrerequistitesOutstanding )


description: Destructor, just checks the life stage

code: virtual ~FBaseGraphTask()


className: FBaseGraphTask

description: Base class for all tasks. Tasks go through a very specific life stage progression, and this is verified.

code: class FBaseGraphTask : private [UE::FInheritedContextBase](API\Runtime\Core\Async\FInheritedContextBase)


description:
Gets stat id for this task.
Stat id.


className: FCustomStatIDGraphTaskBase

description: Class that generalizes functionality of storing and exposing custom stat id. Should only be used as a base of a task graph class with custom stat id.

code: class FCustomStatIDGraphTaskBase


description: Constructor.

code: FCustomStatIDGraphTaskBase ( const [TStatId](API\Runtime\Core\Stats\TStatId) & StatId )


description:
Create a task and dispatch it when the prerequisites are complete
completion handle for the new task

code: static FGraphEventRef CreateAndDispatchWhenReady ( const [FDelegate](API\Runtime\Core\Async\FDelegateGraphTask\FDelegate) & InTaskDeletegate, const [TStatId](API\Runtime\Core\Stats\TStatId) InStatId, const FGraphEventArray * InPrerequisites, [ENamedThreads::Type](API\Runtime\Core\Async\ENamedThreads__Type) InCurrentThreadIfKnown, [ENamedThreads::Type](API\Runtime\Core\Async\ENamedThreads__Type) InDesiredThread )


code: static FGraphEventRef CreateAndDispatchWhenReady ( const [FDelegate](API\Runtime\Core\Async\FDelegateGraphTask\FDelegate) & InTaskDeletegate, const [TStatId](API\Runtime\Core\Stats\TStatId) InStatId, const FGraphEventRef & InPrerequisite, [ENamedThreads::Type](API\Runtime\Core\Async\ENamedThreads__Type) InCurrentThreadIfKnown, [ENamedThreads::Type](API\Runtime\Core\Async\ENamedThreads__Type) InDesiredThread )


code: void DoTask ( [ENamedThreads::Type](API\Runtime\Core\Async\ENamedThreads__Type) CurrentThread, const FGraphEventRef & MyCompletionGraphEvent )


className: FDelegate

code: typedef TBaseDelegate_TwoParams< void, [ENamedThreads::Type](API\Runtime\Core\Async\ENamedThreads__Type), const FGraphEventRef & > FDelegate


description: Task constructor

code: FDelegateGraphTask ( const [FDelegate](API\Runtime\Core\Async\FDelegateGraphTask\FDelegate) & InTaskDeletegate, const [TStatId](API\Runtime\Core\Stats\TStatId) InStatId, [ENamedThreads::Type](API\Runtime\Core\Async\ENamedThreads__Type) InDesiredThread )


className: FDelegateGraphTask

description: Task class for more full featured delegate based tasks. Still less efficient than a custom task, but provides all of the args

code: class FDelegateGraphTask : public [FCustomStatIDGraphTaskBase](API\Runtime\Core\Async\FCustomStatIDGraphTaskBase)

DesiredThread

type: constENamedThr...

description: Thread to run delegate on

TaskDelegate

type: FDelegate

description: Delegate to fire when task runs


className: FEventCount

code: typedef [TEventCount](API\Runtime\Core\Async\TEventCount)< uint32 > FEventCount


className: FEventCountToken

code: typedef [TEventCountToken](API\Runtime\Core\Async\TEventCountToken)< uint32 > FEventCountToken


code: static FGraphEventRef CreateAndDispatchWhenReady ( [TUniqueFunction](API\Runtime\Core\Templates\TUniqueFunction)< void()> InFunction, [TStatId](API\Runtime\Core\Stats\TStatId) InStatId, const FGraphEventArray * InPrerequisites, [ENamedThreads::Type](API\Runtime\Core\Async\ENamedThreads__Type) InDesiredThread )


code: static FGraphEventRef CreateAndDispatchWhenReady ( [TUniqueFunction](API\Runtime\Core\Templates\TUniqueFunction)< void([ENamedThreads::Type](API\Runtime\Core\Async\ENamedThreads__Type), const FGraphEventRef &)> InFunction, [TStatId](API\Runtime\Core\Stats\TStatId) InStatId, const FGraphEventArray * InPrerequisites, [ENamedThreads::Type](API\Runtime\Core\Async\ENamedThreads__Type) InDesiredThread )


code: static FGraphEventRef CreateAndDispatchWhenReady ( [TUniqueFunction](API\Runtime\Core\Templates\TUniqueFunction)< void()> InFunction, [TStatId](API\Runtime\Core\Stats\TStatId) InStatId, const FGraphEventRef & InPrerequisite, [ENamedThreads::Type](API\Runtime\Core\Async\ENamedThreads__Type) InDesiredThread )


code: static FGraphEventRef CreateAndDispatchWhenReady ( [TUniqueFunction](API\Runtime\Core\Templates\TUniqueFunction)< void([ENamedThreads::Type](API\Runtime\Core\Async\ENamedThreads__Type), const FGraphEventRef &)> InFunction, [TStatId](API\Runtime\Core\Stats\TStatId) InStatId, const FGraphEventRef & InPrerequisite, [ENamedThreads::Type](API\Runtime\Core\Async\ENamedThreads__Type) InDesiredThread )


className: FFunctionGraphTask

code: struct FFunctionGraphTask


description: WaitFor

code: bool IsComplete() const


description: Notifies any waiting threads that the result is available.

code: void MarkComplete()


description: Set a continuation to be called on completion of the promise

code: void SetContinuation ( [TUniqueFunction](API\Runtime\Core\Templates\TUniqueFunction)< void()> && Continuation )


description: IsComplete

code: bool WaitFor ( const [FTimespan](API\Runtime\Core\Misc\FTimespan) & Duration ) const


description: Default constructor.

code: FFutureState()


description: Create and initialize a new instance with a callback.

code: FFutureState ( [TUniqueFunction](API\Runtime\Core\Templates\TUniqueFunction)< void()> && InCompletionCallback )


description: Destructor.

code: ~FFutureState()


className: FFutureState

description: Base class for the internal state of asynchronous return values (futures).

code: class FFutureState


description:
Increases the reference count
the new reference count

code: uint32 AddRef()


description: Verification function to ensure that nobody was tried to add WaitUntil's outside of the context of execution

code: void CheckDontCompleteUntilIsEmpty()


description:
Attempts to a new subsequent task. If this event has already fired, false is returned and action must be taken to ensure that the task will still fire even though this event cannot be a prerequisite (because it is already finished).
true if the task was successfully set up as a subsequent. false if the event has already fired.

code: bool AddSubsequent ( class [FBaseGraphTask](API\Runtime\Core\Async\FBaseGraphTask) * Subsequent )


description: Does nothing and is needed only for compatibility with the new frontend

code: FGraphEventRef CreateCompletionHandle()


description:
A factory method to create a graph event.
a reference counted pointer to the new graph event. Note this should be stored in a FGraphEventRef or it will be immediately destroyed!


description: "Complete" the event. This grabs the list of subsequents and atomically closes it. Then for each subsequent it reduces the number of prerequisites outstanding and if that drops to zero, the task is queued.

code: void DispatchSubsequents ( [ENamedThreads::Type](API\Runtime\Core\Async\ENamedThreads__Type) CurrentThreadIfKnown )


description: "Complete" the event. This grabs the list of subsequents and atomically closes it. Then for each subsequent and for each item in "NewTasks" it reduces the number of prerequisites outstanding and if that drops to zero, the task is queued.

code: void DispatchSubsequents ( [TArray](API\Runtime\Core\Containers\TArray)< [FBaseGraphTask](API\Runtime\Core\Async\FBaseGraphTask) * > & NewTasks, [ENamedThreads::Type](API\Runtime\Core\Async\ENamedThreads__Type) CurrentThreadIfKnown, bool bInternal )


description: Delay the firing of this event until the given event fires. CAUTION: This is only legal while executing the task associated with this event.

code: void DontCompleteUntil ( FGraphEventRef EventToWaitFor )


description:
Determine if the event has been completed. This can be used to poll for completion.
true if this event has completed. CAUTION: If this returns false, the event could still end up completing before this function even returns. In other words, a false return does not mean that event is not yet completed!


description:
Decreases the reference count and destroys the graph event if it is zero.
the new reference count

code: uint32 Release()


description: Sets a name for the event for debugging purposes.

code: void SetDebugName ( const TCHAR * Name )


description: Sets the thread that you want to execute the null gather task on. This is useful if the thing waiting for this chain to complete is a single, named thread. CAUTION: This is only legal while executing the task associated with this event.

code: void SetGatherThreadForDontCompleteUntil ( [ENamedThreads::Type](API\Runtime\Core\Async\ENamedThreads__Type) InThreadToDoGatherOn )


description: A convenient short version of `FTaskGraphInterface::WaitUntilTaskCompletes_

code: void Wait ( [ENamedThreads::Type](API\Runtime\Core\Async\ENamedThreads__Type) CurrentThreadIfKnown )


className: FGraphEvent

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

code: class FGraphEvent


description: Must be called in the inherited context, e.g. on launching an async task

code: void CaptureInheritedContext()


description: Must be called where the inherited context should be restored, e.g. at the start of an async task execution


className: FInheritedContextScope

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

code: class FInheritedContextScope


className: FInheritedContextBase

description: This class extends the inherited context (see private members for what the inherited context is) to cover async execution. Is intended to be used as a base class, if the inherited context is compiled out it takes 0 space

code: class FInheritedContextBase


description: Returns true if the event is notified, otherwise false.

code: bool IsNotified() const


className: IsNotifiedFlag

code: static constexpr uint8 IsNotifiedFlag = 1 << 0;


className: MaybeWaitingFlag

code: static constexpr uint8 MaybeWaitingFlag = 1 << 1;


description: Notifies all waiting threads and leaves the event notified until the next call toReset().

code: void Notify()


code: [FManualResetEvent](API\Runtime\Core\Async\FManualResetEvent) & operator= ( const [FManualResetEvent](API\Runtime\Core\Async\FManualResetEvent) & )


description: Resets the event to a non-notified state.

code: void Reset()


description: Wait until the event is notified.

code: void Wait()


description:
Wait until the event is notified.
True if the event was notified before the wait time elapsed, otherwise false.

code: bool WaitFor ( [FMonotonicTimeSpan](API\Runtime\Core\Misc\FMonotonicTimeSpan) WaitTime )


code: bool WaitUntil ( [FMonotonicTimePoint](API\Runtime\Core\Misc\FMonotonicTimePoint) WaitTime )


code: FManualResetEvent ( const [FManualResetEvent](API\Runtime\Core\Async\FManualResetEvent) & )


className: HasWaitingThreadsFlag

code: static constexpr uint8 HasWaitingThreadsFlag = 1 << 1;


className: FManualResetEvent

description: A type of event that remains notified until manually reset.

code: class FManualResetEvent


className: IsLockedFlag

code: static constexpr uint8 IsLockedFlag = 1 << 0;


code: [FMutex](API\Runtime\Core\Async\FMutex) & operator= ( const [FMutex](API\Runtime\Core\Async\FMutex) & )


code: FMutex ( const [FMutex](API\Runtime\Core\Async\FMutex) & )


className: FMutex

description: A one-byte mutex that is not fair and does not support recursive locking.

code: class FMutex


className: FNonAbandonableTask

description: Stub class to use a base class for tasks that cannot be abandoned

code: class FNonAbandonableTask


description: Actually execute the task.

code: void DoTask ( [ENamedThreads::Type](API\Runtime\Core\Async\ENamedThreads__Type) CurrentThread, const FGraphEventRef & MyCompletionGraphEvent )


description:
Retrieve the thread that this task wants to run on.
the thread that this task should run on.


description: Constructor

code: FNullGraphTask ( const [TStatId](API\Runtime\Core\Stats\TStatId) & StatId, [ENamedThreads::Type](API\Runtime\Core\Async\ENamedThreads__Type) InDesiredThread )


className: FNullGraphTask

description: FNullGraphTaskis a task that does nothing. It can be used to "gather" tasks into one prerequisite.

code: class FNullGraphTask : public [FCustomStatIDGraphTaskBase](API\Runtime\Core\Async\FCustomStatIDGraphTaskBase)


code: constexpr bool operator&61;&61; &40; const FState & Other &41; const


code: constexpr FState &40; uint32 State &41;


className: FState

code: union FState

bHasWaitingThreads

type: uint32:  1


code: [FRecursiveMutex](API\Runtime\Core\Async\FRecursiveMutex) & operator= ( const [FRecursiveMutex](API\Runtime\Core\Async\FRecursiveMutex) & )


code: FRecursiveMutex ( const [FRecursiveMutex](API\Runtime\Core\Async\FRecursiveMutex) & )


className: FRecursiveMutex

description: PreferFMutexwhen recursive locking is not required.

code: class FRecursiveMutex


className: RenderThread

description: These are private to prevent direct access by anything except the friend functions below.

code: static [TAtomic](API\Runtime\Core\HAL\TAtomic)< [Type](API\Runtime\Core\Async\ENamedThreads__Type) > RenderThread;


code: static [TAtomic](API\Runtime\Core\HAL\TAtomic)< [Type](API\Runtime\Core\Async\ENamedThreads__Type) > RenderThread_Local;


className: FRenderThreadStatics

code: struct FRenderThreadStatics


description: Constructor

code: FReturnGraphTask ( [ENamedThreads::Type](API\Runtime\Core\Async\ENamedThreads__Type) InThreadToReturnFrom )


className: FReturnGraphTask

description: FReturnGraphTaskis a task used to return flow control from a named thread back to the original caller of ProcessThreadUntilRequestReturn

code: class FReturnGraphTask


description:
Create a task and dispatch it when the prerequisites are complete
completion handle for the new task

code: static FGraphEventRef CreateAndDispatchWhenReady ( const [FDelegate](API\Runtime\Core\Async\FSimpleDelegateGraphTask\FDelegate) & InTaskDeletegate, const [TStatId](API\Runtime\Core\Stats\TStatId) InStatId, const FGraphEventArray * InPrerequisites, [ENamedThreads::Type](API\Runtime\Core\Async\ENamedThreads__Type) InDesiredThread )


code: static FGraphEventRef CreateAndDispatchWhenReady ( const [FDelegate](API\Runtime\Core\Async\FSimpleDelegateGraphTask\FDelegate) & InTaskDeletegate, const [TStatId](API\Runtime\Core\Stats\TStatId) && InStatId, const FGraphEventRef & InPrerequisite, [ENamedThreads::Type](API\Runtime\Core\Async\ENamedThreads__Type) InDesiredThread )


className: FDelegate

code: typedef TBaseDelegate_NoParams< void > FDelegate


description: Task constructor

code: FSimpleDelegateGraphTask ( const [FDelegate](API\Runtime\Core\Async\FSimpleDelegateGraphTask\FDelegate) & InTaskDeletegate, const [TStatId](API\Runtime\Core\Stats\TStatId) StatId, [ENamedThreads::Type](API\Runtime\Core\Async\ENamedThreads__Type) InDesiredThread )


className: FSimpleDelegateGraphTask

description: Task class for simple delegate based tasks. This is less efficient than a custom task, doesn't provide the task arguments, doesn't allow specification of the current thread, etc.

code: class FSimpleDelegateGraphTask : public [FCustomStatIDGraphTaskBase](API\Runtime\Core\Async\FCustomStatIDGraphTaskBase)

DesiredThread

description: Thread to run delegate on

TaskDelegate

description: Delegate to fire when task runs


className: Allocator

code: typedef [TBlockAllocationCache](API\Runtime\Core\Experimental\TBlockAllocationCache)< BlockSize, FAlignedAllocator > Allocator


className: AllowOversizedBlocks

code: static constexpr bool AllowOversizedBlocks = false;


className: BlockSize

code: static constexpr uint32 BlockSize = 64 * 1024;


className: InlineBlockAllocation

code: static constexpr bool InlineBlockAllocation = true;


className: RequiresAccurateSize

code: static constexpr bool RequiresAccurateSize = false;


className: TagName

code: static constexpr const char * TagName = "TaskLinearAllocator";


className: FTaskBlockAllocationTag

code: struct FTaskBlockAllocationTag : public [FDefaultBlockAllocationTag](API\Runtime\Core\Experimental\FDefaultBlockAllocationTag)


code: static constexpr const char * TagName = "TaskGraphLinear";


className: FTaskGraphBlockAllocationTag

code: struct FTaskGraphBlockAllocationTag : public [FDefaultBlockAllocationTag](API\Runtime\Core\Experimental\FDefaultBlockAllocationTag)


description: Delegates for shutdown

code: void AddShutdownCallback ( [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< void()> & Callback )


description: A one time call that "introduces" an external thread to the system. Basically, it just sets up the TLS info

code: void AttachToThread ( [ENamedThreads::Type](API\Runtime\Core\Async\ENamedThreads__Type) CurrentThread )


description: A (slow) function to call a function on every known thread, both named and workers

code: static void BroadcastSlow_OnlyUseForSpecialPurposes ( bool bDoTaskThreads, bool bDoBackgroundThreads, [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< void([ENamedThreads::Type](API\Runtime\Core\Async\ENamedThreads__Type) CurrentThread)> & Callback )


code: [FBaseGraphTask](API\Runtime\Core\Async\FBaseGraphTask) * FindWork ( [ENamedThreads::Type](API\Runtime\Core\Async\ENamedThreads__Type) ThreadInNeed )


description:
Singleton for the system
a reference to the task graph system

code: static [FTaskGraphInterface](API\Runtime\Core\Async\FTaskGraphInterface) & Get()


description: Return the current thread type, if known.

code: [ENamedThreads::Type](API\Runtime\Core\Async\ENamedThreads__Type) GetCurrentThreadIfKnown ( bool bLocalQueue )


description: Return the number of background worker threads. If the old backend is used, return the number of background workers (0 if background workers are disabled).

code: int32 GetNumBackgroundThreads()


description: Return the number of foreground worker threads. If the old backend is used, return the number of high-pri workers (0 if high-pri workers are disabled).

code: int32 GetNumForegroundThreads()


description: Return the number of worker (non-named) threads PER PRIORITY SET. This is useful for determining how many tasks to split a job into.

code: int32 GetNumWorkerThreads()


description: Return true if the current thread is known.

code: bool IsCurrentThreadKnown()


description: The task graph is always multi-threaded for platforms that support it. For forked processes, the taskgraph will be singlethread for the master process but becomes multithread in the forked process

code: static bool IsMultithread()


description: Check to see if the system is running.

code: static bool IsRunning()


description: Return true if the given named thread is processing tasks. This is only a "guess" if you ask for a thread other than yourself because that can change before the function returns.

code: bool IsThreadProcessingTasks ( [ENamedThreads::Type](API\Runtime\Core\Async\ENamedThreads__Type) ThreadToCheck )


description: Requests that a named thread, which must be this thread, run until idle, then return.

code: uint64 ProcessThreadUntilIdle ( [ENamedThreads::Type](API\Runtime\Core\Async\ENamedThreads__Type) CurrentThread )


description: Requests that a named thread, which must be this thread, run until an explicit return request is received, then return.

code: void ProcessThreadUntilRequestReturn ( [ENamedThreads::Type](API\Runtime\Core\Async\ENamedThreads__Type) CurrentThread )


description: Request that the given thread stop when it is idle

code: void RequestReturn ( [ENamedThreads::Type](API\Runtime\Core\Async\ENamedThreads__Type) CurrentThread )


description: Explicit start call to shutdown the system. This is unlikely to work unless the system is idle.

code: static void Shutdown()


code: void StallForTuning ( int32 Index, bool Stall )


description: Explicit start call for the system. The ordinary singleton pattern does not work because internal threads start asking for the singleton before the constructor has returned.

code: static void Startup ( int32 NumThreads )


description: When a task completes, fire a scoped event

code: void TriggerEventWhenTaskCompletes ( [FEvent](API\Runtime\Core\HAL\FEvent) * InEvent, const FGraphEventRef & Task, [ENamedThreads::Type](API\Runtime\Core\Async\ENamedThreads__Type) CurrentThreadIfKnown, [ENamedThreads::Type](API\Runtime\Core\Async\ENamedThreads__Type) TriggerThread )


description: When a set of tasks complete, fire a scoped event

code: void TriggerEventWhenTasksComplete ( [FEvent](API\Runtime\Core\HAL\FEvent) * InEvent, const FGraphEventArray & Tasks, [ENamedThreads::Type](API\Runtime\Core\Async\ENamedThreads__Type) CurrentThreadIfKnown, [ENamedThreads::Type](API\Runtime\Core\Async\ENamedThreads__Type) TriggerThread )


description: Requests that a named thread, which must be this thread, run until a task is complete

code: void WaitUntilTaskCompletes ( const FGraphEventRef & Task, [ENamedThreads::Type](API\Runtime\Core\Async\ENamedThreads__Type) CurrentThreadIfKnown )


description: Requests that a named thread, which must be this thread, run until a list of tasks is complete.

code: void WaitUntilTasksComplete ( const FGraphEventArray & Tasks, [ENamedThreads::Type](API\Runtime\Core\Async\ENamedThreads__Type) CurrentThreadIfKnown )


code: void WakeNamedThread ( [ENamedThreads::Type](API\Runtime\Core\Async\ENamedThreads__Type) ThreadToWake )


className: FTaskGraphInterface

description: Interface to the task graph system

code: class FTaskGraphInterface


code: FTaskTimingEventScope ( [TaskTrace::FId](API\Runtime\Core\Async\FId) InTaskId )


className: FTaskTimingEventScope

code: struct FTaskTimingEventScope


code: void WaitUntilTaskCompletes ( FGraphEventRef && Task, [ENamedThreads::Type](API\Runtime\Core\Async\ENamedThreads__Type) CurrentThreadIfKnown )


code: void DoTask ( [ENamedThreads::Type](API\Runtime\Core\Async\ENamedThreads__Type) CurrentThread, const FGraphEventRef & MyCompletionGraphEvent )


description: Constructor

code: FTriggerEventGraphTask ( [FEvent](API\Runtime\Core\HAL\FEvent) * InEvent, [ENamedThreads::Type](API\Runtime\Core\Async\ENamedThreads__Type) InDesiredThread )


className: FTriggerEventGraphTask

description: FTriggerEventGraphTaskis a task that triggers an event

code: class FTriggerEventGraphTask


code: typedef [TBlockAllocationCache](API\Runtime\Core\Experimental\TBlockAllocationCache)< BlockSize, FAlignedAllocator > Allocator


code: static constexpr bool AllowOversizedBlocks = true;


code: static constexpr uint32 BlockSize = 64 * 1024;


code: static constexpr bool InlineBlockAllocation = true;


code: static constexpr bool RequiresAccurateSize = false;


code: static constexpr const char * TagName = "LowLevelTasksLinear";


className: FLowLevelTasksBlockAllocationTag

code: struct FLowLevelTasksBlockAllocationTag : public [FDefaultBlockAllocationTag](API\Runtime\Core\Experimental\FDefaultBlockAllocationTag)


description: Tries to yield this thread using the YieldEvent and do busywork on a reserve worker.

code: bool DoReserveWorkUntil ( [FConditional](API\Runtime\Core\Async\Fundamental\FReserveScheduler\FConditional) && Condition )


className: FConditional

code: typedef [TTaskDelegate](API\Runtime\Core\Async\Fundamental\TTaskDelegate)< bool(), 16 > FConditional


code: static [FReserveScheduler](API\Runtime\Core\Async\Fundamental\FReserveScheduler) & Get()


description: Start number of reserve workers where 0 is the system default

code: void StartWorkers ( uint32 ReserveWorkers, [FThread::EForkable](API\Runtime\Core\HAL\FThread\EForkable) IsForkable, EThreadPriority WorkerPriority )


code: FReserveScheduler &40; FReserveScheduler && &41;


code: FReserveScheduler &40; const FReserveScheduler & &41;


description: Tries to do some work until the Task is completed

code: template<typename TaskType> void BusyWait ( const TaskType & Task, bool ForceAllowBackgroundWork )


description: Tries to do some work until all the Tasks are completed the template parameter can be any Type that has a const conversion operator toFTask

code: template<typename TaskType> void BusyWait ( const [TArrayView](API\Runtime\Core\Containers\TArrayView)< const TaskType > & Tasks, bool ForceAllowBackgroundWork )


className: FReserveScheduler

code: class FReserveScheduler : public [LowLevelTasks::FSchedulerTls](API\Runtime\Core\Async\Fundamental\FSchedulerTls)


description: Tries to do some work until the Conditional return true

code: template<typename Conditional> void BusyWaitUntil ( Conditional && Cond, bool ForceAllowBackgroundWork )


description: Using 16 bytes here because it fits the vtable and one additional pointer


description: Number of instantiated workers

code: uint32 GetNumWorkers() const


description: Get the background priority set when workers were started


code: static [FScheduler](API\Runtime\Core\Async\Fundamental\FScheduler) & Get()


description: Get the worker priority set when workers were started


code: void RestartWorkers ( uint32 NumForegroundWorkers, uint32 NumBackgroundWorkers, [FThread::EForkable](API\Runtime\Core\HAL\FThread\EForkable) IsForkable, EThreadPriority WorkerPriority, EThreadPriority BackgroundPriority, uint64 InWorkerAffinity, uint64 InBackgroundAffinity )


description: Start number of workers where 0 is the system default

code: void StartWorkers ( uint32 NumForegroundWorkers, uint32 NumBackgroundWorkers, [FThread::EForkable](API\Runtime\Core\HAL\FThread\EForkable) IsForkable, EThreadPriority InWorkerPriority, EThreadPriority InBackgroundPriority, uint64 InWorkerAffinity, uint64 InBackgroundAffinity )


code: void StopWorkers ( bool DrainGlobalQueue )


description: Try to launch the task, the return value will specify if the task was in the ready state and has been launhced

code: bool TryLaunch ( [FTask](API\Runtime\Core\Async\Fundamental\FTask) & Task, [EQueuePreference](API\Runtime\Core\Async\Fundamental\LowLevelTasks__EQueuePreference) QueuePreference, bool bWakeUpWorker )


description: Try to launch the task on a specific worker ID, the return value will specify if the task was in the ready state and has been launched

code: bool TryLaunchAffinity ( [FTask](API\Runtime\Core\Async\Fundamental\FTask) & Task, uint32 AffinityIndex )


className: WorkerSpinCycles

code: static constexpr uint32 WorkerSpinCycles = 53;


code: FScheduler &40; const FScheduler & &41;


className: FScheduler

code: class FScheduler : public [LowLevelTasks::FSchedulerTls](API\Runtime\Core\Async\Fundamental\FSchedulerTls)


className: EWorkerType

code: enum EWorkerType { None, Background, Foreground, }


className: BusyWaitingDepth

description: Number of busy-waiting calls in the call-stack

code: static thread_local uint32 BusyWaitingDepth = 0;


className: ActiveScheduler

code: static thread_local [FSchedulerTls](API\Runtime\Core\Async\Fundamental\FSchedulerTls) * ActiveScheduler = nullptr;


description: Returns the AffinityIndex of the thread LocalQueue

code: static uint32 GetAffinityIndex()


className: LocalQueue

code: static thread_local [FLocalQueueType](API\Runtime\Core\Async\Fundamental\FSchedulerTls\FLocalQueueType) * LocalQueue = nullptr;


description: Returns true if the current thread execution is in the context of busy-waiting

code: static bool IsBusyWaiting()


className: WorkerType

code: static thread_local [EWorkerType](API\Runtime\Core\Async\Fundamental\FSchedulerTls\EWorkerType) WorkerType = FSchedulerTls::EWorkerType::None;


className: FSleepEvent

description: The struct is naturally 64 bytes aligned, the extra alignment just re-enforces this assumption and will error if it changes in the future

code: struct FSleepEvent

SleepEvent

type: FEventRef


className: ActiveTask

code: static thread_local [FTask](API\Runtime\Core\Async\Fundamental\FTask) * ActiveTask = nullptr;


className: FInitData

code: struct FInitData

DebugName

type: const TCHAR ...

Flags

type: ETaskFlags

Priority

type: ETaskPriority


description: Get the currently active task if any

code: static const [FTask](API\Runtime\Core\Async\Fundamental\FTask) * GetActiveTask()


code: template<typename TRunnable> void Init ( const TCHAR * InDebugName, TRunnable && InRunnable, [ETaskFlags](API\Runtime\Core\Async\Fundamental\LowLevelTasks__ETaskFlags) Flags )


code: template<typename TRunnable> void Init ( const TCHAR * InDebugName, [ETaskPriority](API\Runtime\Core\Async\Fundamental\LowLevelTasks__ETaskPriority) InPriority, TRunnable && InRunnable, [ETaskFlags](API\Runtime\Core\Async\Fundamental\LowLevelTasks__ETaskFlags) Flags )


description: Means the task is completed and this taskhandle can be recycled

code: bool IsCompleted ( std::memory_order MemoryOrder ) const


description: Means the task is ready to be launched but might already been canceled

code: bool IsReady() const


code: void SetUserData ( void * NewUserData ) const


description: Try to cancel the task if it has not been launched yet.

code: bool TryCancel ( [ECancellationFlags](API\Runtime\Core\Async\Fundamental\LowLevelTasks__ECancellationFlag-) CancellationFlags )


description: Try to execute the task if it has not been launched yet the task will execute immediately.

code: bool TryExecute ( [FTask](API\Runtime\Core\Async\Fundamental\FTask) *& Continuation )


code: bool TryExecute()


description: Try to expedite the task if succeded it will run immediately but it will not set the completed state until the scheduler has executed it, because the scheduler still holds a reference. to check for completion in the context of expediting use WasExpedited. The TaskHandle canot be reused until IsCompleted returns true.

code: bool TryExpedite()


code: bool TryExpedite ( [FTask](API\Runtime\Core\Async\Fundamental\FTask) *& Continuation )


description: Try to revive a canceled task (as in reverting the cancellation as if it never happened). if it had been canceled and the scheduler has not run it yet it succeeds.

code: bool TryRevive()


description: Means the task was canceled but might still need to be launched

code: bool WasCanceled() const


description: Means the task was expedited or that it already completed

code: bool WasExpedited() const


className: FTask

description: Minimal low level task interface

code: class FTask : private [LowLevelTasks::Tasks_Impl::FTaskBase](API\Runtime\Core\Async\Fundamental\FTaskBase)


className: FTaskDelegate

code: typedef [TTaskDelegate](API\Runtime\Core\Async\Fundamental\TTaskDelegate)< [FTask](API\Runtime\Core\Async\Fundamental\FTask) *(bool), 64-sizeof(FPackedData)-sizeof(void *)> FTaskDelegate


className: FTaskBase

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

code: class FTaskBase


code: namespace LowLevelTasks { void LowLevelTasks::BusyWaitForTask ( const [FTask](API\Runtime\Core\Async\Fundamental\FTask) & Task, bool ForceAllowBackgroundWork ) }


code: namespace LowLevelTasks { template<typename TaskType> void LowLevelTasks::BusyWaitForTasks ( const [TArrayView](API\Runtime\Core\Containers\TArrayView)< const TaskType > & Tasks, bool ForceAllowBackgroundWork ) }


code: namespace LowLevelTasks { template<typename Conditional> void LowLevelTasks::BusyWaitUntil ( Conditional && Cond, bool ForceAllowBackgroundWork ) }


code: namespace LowLevelTasks { bool LowLevelTasks::DoReserveWorkUntil ( [FReserveScheduler::FConditional](API\Runtime\Core\Async\Fundamental\FReserveScheduler\FConditional) && Condition ) }


code: namespace LowLevelTasks { enum ECancellationFlags { None = 0 << 0, TryLaunchOnSuccess = 1 << 0, PrelaunchCancellation = 1 << 1, DefaultFlags = TryLaunchOnSuccess | PrelaunchCancellation, } }


code: namespace LowLevelTasks { enum ELocalQueueType { EBackground, EForeground, } }


code: namespace LowLevelTasks { enum EQueuePreference { GlobalQueuePreference, LocalQueuePreference, DefaultPreference = LocalQueuePreference, } }


code: namespace LowLevelTasks { enum ESleepState { Affinity, Running, Drowsing, Sleeping, } }


code: namespace LowLevelTasks { enum ETaskFlags { AllowNothing = 0 << 0, AllowBusyWaiting = 1 << 0, AllowCancellation = 1 << 1, AllowEverything = AllowBusyWaiting | AllowCancellation, DefaultFlags = AllowEverything, } }


code: namespace LowLevelTasks { enum ETaskPriority { High, Normal, Default = Normal, ForegroundCount, BackgroundHigh = ForegroundCount, BackgroundNormal, BackgroundLow, Count, Inherit, } }


description: (I)nitThread: STORE(I)-------------------CAS(C)------------------- (C)ancelingThread: >| Ready |<>| CanceledAndReady |

code: namespace LowLevelTasks { enum ETaskState { ReadyState = 0, CanceledFlag = 1 << 0, ScheduledFlag = 1 << 1, RunningFlag = 1 << 2, ExpeditingFlag = 1 << 3, ExpeditedFlag = 1 << 4, CompletedFlag = 1 << 5, Count = (1 << 6) - 1, Ready = ReadyState, CanceledAndReady = Ready | CanceledFlag, Scheduled = Ready | ScheduledFlag, Canceled = CanceledAndReady | ScheduledFlag, Running = Scheduled | RunningFlag, CanceledAndRunning = Canceled | RunningFlag, Expediting = Running | ExpeditingFlag, Expedited = Expediting | ExpeditedFlag, Completed = Running | CompletedFlag, ExpeditedAndCompleted = Expedited | CompletedFlag, CanceledAndCompleted = CanceledAndRunning | CompletedFlag, } }


code: namespace LowLevelTasks { [ECancellationFlags](API\Runtime\Core\Async\Fundamental\LowLevelTasks__ECancellationFlag-) & LowLevelTasks::operator&= ( [ECancellationFlags](API\Runtime\Core\Async\Fundamental\LowLevelTasks__ECancellationFlag-) & Lhs, [ECancellationFlags](API\Runtime\Core\Async\Fundamental\LowLevelTasks__ECancellationFlag-) Rhs ) }


code: namespace LowLevelTasks { [ETaskState](API\Runtime\Core\Async\Fundamental\LowLevelTasks__ETaskState) & LowLevelTasks::operator&= ( [ETaskState](API\Runtime\Core\Async\Fundamental\LowLevelTasks__ETaskState) & Lhs, [ETaskState](API\Runtime\Core\Async\Fundamental\LowLevelTasks__ETaskState) Rhs ) }


code: namespace LowLevelTasks { [ECancellationFlags](API\Runtime\Core\Async\Fundamental\LowLevelTasks__ECancellationFlag-) & LowLevelTasks::operator^= ( [ECancellationFlags](API\Runtime\Core\Async\Fundamental\LowLevelTasks__ECancellationFlag-) & Lhs, [ECancellationFlags](API\Runtime\Core\Async\Fundamental\LowLevelTasks__ECancellationFlag-) Rhs ) }


code: namespace LowLevelTasks { [ETaskFlags](API\Runtime\Core\Async\Fundamental\LowLevelTasks__ETaskFlags) & LowLevelTasks::operator^= ( [ETaskFlags](API\Runtime\Core\Async\Fundamental\LowLevelTasks__ETaskFlags) & Lhs, [ETaskFlags](API\Runtime\Core\Async\Fundamental\LowLevelTasks__ETaskFlags) Rhs ) }


code: namespace LowLevelTasks { [ETaskFlags](API\Runtime\Core\Async\Fundamental\LowLevelTasks__ETaskFlags) & LowLevelTasks::operator&= ( [ETaskFlags](API\Runtime\Core\Async\Fundamental\LowLevelTasks__ETaskFlags) & Lhs, [ETaskFlags](API\Runtime\Core\Async\Fundamental\LowLevelTasks__ETaskFlags) Rhs ) }


code: namespace LowLevelTasks { [ETaskState](API\Runtime\Core\Async\Fundamental\LowLevelTasks__ETaskState) & LowLevelTasks::operator^= ( [ETaskState](API\Runtime\Core\Async\Fundamental\LowLevelTasks__ETaskState) & Lhs, [ETaskState](API\Runtime\Core\Async\Fundamental\LowLevelTasks__ETaskState) Rhs ) }


code: namespace LowLevelTasks { constexpr [ECancellationFlags](API\Runtime\Core\Async\Fundamental\LowLevelTasks__ECancellationFlag-) LowLevelTasks::operator& ( [ECancellationFlags](API\Runtime\Core\Async\Fundamental\LowLevelTasks__ECancellationFlag-) Lhs, [ECancellationFlags](API\Runtime\Core\Async\Fundamental\LowLevelTasks__ECancellationFlag-) Rhs ) }


code: namespace LowLevelTasks { constexpr [ETaskFlags](API\Runtime\Core\Async\Fundamental\LowLevelTasks__ETaskFlags) LowLevelTasks::operator& ( [ETaskFlags](API\Runtime\Core\Async\Fundamental\LowLevelTasks__ETaskFlags) Lhs, [ETaskFlags](API\Runtime\Core\Async\Fundamental\LowLevelTasks__ETaskFlags) Rhs ) }


code: namespace LowLevelTasks { constexpr [ETaskState](API\Runtime\Core\Async\Fundamental\LowLevelTasks__ETaskState) LowLevelTasks::operator& ( [ETaskState](API\Runtime\Core\Async\Fundamental\LowLevelTasks__ETaskState) Lhs, [ETaskState](API\Runtime\Core\Async\Fundamental\LowLevelTasks__ETaskState) Rhs ) }


code: namespace LowLevelTasks { constexpr [ECancellationFlags](API\Runtime\Core\Async\Fundamental\LowLevelTasks__ECancellationFlag-) LowLevelTasks::operator^ ( [ECancellationFlags](API\Runtime\Core\Async\Fundamental\LowLevelTasks__ECancellationFlag-) Lhs, [ECancellationFlags](API\Runtime\Core\Async\Fundamental\LowLevelTasks__ECancellationFlag-) Rhs ) }


code: namespace LowLevelTasks { constexpr [ETaskState](API\Runtime\Core\Async\Fundamental\LowLevelTasks__ETaskState) LowLevelTasks::operator^ ( [ETaskState](API\Runtime\Core\Async\Fundamental\LowLevelTasks__ETaskState) Lhs, [ETaskState](API\Runtime\Core\Async\Fundamental\LowLevelTasks__ETaskState) Rhs ) }


code: namespace LowLevelTasks { constexpr [ETaskFlags](API\Runtime\Core\Async\Fundamental\LowLevelTasks__ETaskFlags) LowLevelTasks::operator^ ( [ETaskFlags](API\Runtime\Core\Async\Fundamental\LowLevelTasks__ETaskFlags) Lhs, [ETaskFlags](API\Runtime\Core\Async\Fundamental\LowLevelTasks__ETaskFlags) Rhs ) }


code: namespace LowLevelTasks { constexpr bool LowLevelTasks::operator! ( [ECancellationFlags](API\Runtime\Core\Async\Fundamental\LowLevelTasks__ECancellationFlag-) E ) }


code: namespace LowLevelTasks { constexpr bool LowLevelTasks::operator! ( [ETaskFlags](API\Runtime\Core\Async\Fundamental\LowLevelTasks__ETaskFlags) E ) }


code: namespace LowLevelTasks { constexpr [ECancellationFlags](API\Runtime\Core\Async\Fundamental\LowLevelTasks__ECancellationFlag-) LowLevelTasks::operator~ ( [ECancellationFlags](API\Runtime\Core\Async\Fundamental\LowLevelTasks__ECancellationFlag-) E ) }


code: namespace LowLevelTasks { constexpr [ETaskFlags](API\Runtime\Core\Async\Fundamental\LowLevelTasks__ETaskFlags) LowLevelTasks::operator~ ( [ETaskFlags](API\Runtime\Core\Async\Fundamental\LowLevelTasks__ETaskFlags) E ) }


code: namespace LowLevelTasks { constexpr [ETaskState](API\Runtime\Core\Async\Fundamental\LowLevelTasks__ETaskState) LowLevelTasks::operator~ ( [ETaskState](API\Runtime\Core\Async\Fundamental\LowLevelTasks__ETaskState) E ) }


description: LowLevelTasks::TTaskDelegate_Impl::MakeDummyValue< void >

code: namespace LowLevelTasks { namespace TTaskDelegate_Impl { template<typename ReturnType> ReturnType LowLevelTasks::TTaskDelegate_Impl::MakeDummyValue() } }


code: namespace LowLevelTasks { namespace TTaskDelegate_Impl { template<> void LowLevelTasks::TTaskDelegate_Impl::MakeDummyValue< void >() } }


code: namespace LowLevelTasks { const TCHAR * LowLevelTasks::ToString ( [ETaskPriority](API\Runtime\Core\Async\Fundamental\LowLevelTasks__ETaskPriority) Priority ) }


code: namespace LowLevelTasks { bool LowLevelTasks::ToTaskPriority ( const TCHAR * PriorityStr, [ETaskPriority](API\Runtime\Core\Async\Fundamental\LowLevelTasks__ETaskPriority) & OutPriority ) }


code: namespace LowLevelTasks { bool LowLevelTasks::TryLaunch ( [FTask](API\Runtime\Core\Async\Fundamental\FTask) & Task, [EQueuePreference](API\Runtime\Core\Async\Fundamental\LowLevelTasks__EQueuePreference) QueuePreference, bool bWakeUpWorker ) }


code: namespace LowLevelTasks { bool LowLevelTasks::TryLaunchAffinity ( [FTask](API\Runtime\Core\Async\Fundamental\FTask) & Task, uint32 AffinityIndex ) }


className: TAlignedArray

code: typedef [TArray](API\Runtime\Core\Containers\TArray)< NodeType, [TAlignedHeapAllocator](API\Runtime\Core\Containers\TAlignedHeapAllocator)< alignof(NodeType)>> TAlignedArray


code: namespace LowLevelTasks { constexpr bool LowLevelTasks::operator! ( [ETaskState](API\Runtime\Core\Async\Fundamental\LowLevelTasks__ETaskState) E ) }


code: TDeleter ( const [TDeleter](API\Runtime\Core\Async\Fundamental\TDeleter) & )


code: TDeleter ( [TDeleter](API\Runtime\Core\Async\Fundamental\TDeleter) && Other )


className: TDeleter

description: Generic implementation of a Deleter, it often comes up that one has to call a function to cleanup after a Task finished this can be done by capturing aTDeleterlike so:Deleter(LowLevelTasks::TDeleter(value)){}

code: template<typename Type, void(Type::*)() DeleteFunction> class TDeleter


code: static constexpr uint32 EVENT_INDEX_NONE = -1;


code: TEventStack ( [TAlignedArray](API\Runtime\Core\Async\Fundamental\TAlignedArray)< NodeType > & NodesArray )


className: TEventStack

description: Implementation of a treiber stack

code: template<typename NodeType> class TEventStack


description: Grab an Item directy from the Global OverflowQueue

code: [FTask](API\Runtime\Core\Async\Fundamental\FTask) * DequeueGlobal ( bool GetBackGroundTasks, bool bDisableThrottleStealing )


className: DequeueHazard

code: typedef typename FOverflowQueueType::DequeueHazard DequeueHazard


code: [FTask](API\Runtime\Core\Async\Fundamental\FTask) * DequeueSteal ( bool GetBackGroundTasks, bool bDisableThrottleStealing )


description: Enqueue an Item directy into the Global OverflowQueue returns true if we should wake a worker for stealing

code: bool Enqueue ( [FTask](API\Runtime\Core\Async\Fundamental\FTask) * Item, uint32 PriorityIndex )


code: bool EnqueueAffinity ( [FTask](API\Runtime\Core\Async\Fundamental\FTask) * Item, uint32 AffinityIndex )


className: FLocalQueueType

code: typedef [LocalQueue_Impl::TWorkStealingQueue2](API\Runtime\Core\Async\Fundamental\TWorkStealingQueue2)< [FTask](API\Runtime\Core\Async\Fundamental\FTask), NumLocalItems > FLocalQueueType


className: FOutOfWork

code: class FOutOfWork


className: FOverflowQueueType

code: typedef FAAArrayQueue< [FTask](API\Runtime\Core\Async\Fundamental\FTask) > FOverflowQueueType


code: [FOutOfWork](API\Runtime\Core\Async\Fundamental\TLocalQueueRegistry\FOutOfWork) GetOutOfWorkScope ( [ELocalQueueType](API\Runtime\Core\Async\Fundamental\LowLevelTasks__ELocalQueueType) QueueType )


code: FTask &42; DequeueAffinity &40; bool GetBackGroundTasks, bool bDisableThrottleStealing &41;


code: FTask &42; DequeueGlobal &40; bool GetBackGroundTasks, bool bDisableThrottleStealing &41;


code: FTask &42; DequeueLocal &40; bool GetBackGroundTasks, bool bDisableThrottleStealing &41;


code: FTask &42; DequeueSteal &40; bool GetBackGroundTasks, bool bDisableThrottleStealing &41;


description: Add an item to the local queue and overflow into the global queue if full returns true if we should wake a worker

code: bool Enqueue &40; FTask &42; Item, uint32 PriorityIndex &41;


className: InvalidIndex

code: static InvalidIndex = ~0u;


code: TLocalQueue &40; TLocalQueueRegistry & InRegistry, ELocalQueueType InQueueType, FSleepEvent &42; InSleepEvent &41;


code: uint32 GetAffinityIndex&40;&41; const


className: TLocalQueueRegistry

code: template<uint32 NumLocalItems> class TLocalQueueRegistry


className: TTaskDelegate

description: TTaskDelegate< ReturnType(ParamTypes...), TotalSize >

code: template<typename, uint32> class TTaskDelegate


className: TTaskDelegate< ReturnType(ParamTypes...), TotalSize >::CallAndMove

code: template<uint32 DestTotalSize> ReturnType CallAndMove &40; TTaskDelegate< ReturnType(ParamTypes...), DestTotalSize > & Destination, ParamTypes... Params &41;


className: TTaskDelegate< ReturnType(ParamTypes...), TotalSize >::DelegateSize

code: uint32 DelegateSize&40;&41; const


className: TTaskDelegate< ReturnType(ParamTypes...), TotalSize >::Destroy

code: void Destroy&40;&41;


className: InlineStorageSize

code: static InlineStorageSize = TotalSize - sizeof(TTaskDelegateBase);


className: TTaskDelegate< ReturnType(ParamTypes...), TotalSize >::IsHeapAllocated

code: bool IsHeapAllocated&40;&41; const


className: TTaskDelegate< ReturnType(ParamTypes...), TotalSize >::IsSet

code: bool IsSet&40;&41; const


className: TTaskDelegate< ReturnType(ParamTypes...), TotalSize >::operator()

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


className: TTaskDelegate< ReturnType(ParamTypes...), TotalSize >::operator=

code: template<uint32 SourceTotalSize> ThisClass & operator&61; &40; const TTaskDelegate< ReturnType(ParamTypes...), SourceTotalSize > & &41;


code: template<uint32 SourceTotalSize> ThisClass & operator&61; &40; TTaskDelegate< ReturnType(ParamTypes...), SourceTotalSize > && Other &41;


className: ThisClass

code: typedef TTaskDelegate< ReturnType(ParamTypes...), TotalSize > ThisClass


code: template<typename CallableT> ThisClass & operator&61; &40; CallableT && Callable &41;


className: TTaskDelegate< ReturnType(ParamTypes...), TotalSize >::TTaskDelegate


code: template<uint32 SourceTotalSize> TTaskDelegate &40; const TTaskDelegate< ReturnType(ParamTypes...), SourceTotalSize > & &41;


code: template<uint32 SourceTotalSize> TTaskDelegate &40; TTaskDelegate< ReturnType(ParamTypes...), SourceTotalSize > && Other &41;


code: template<typename CallableT> TTaskDelegate &40; CallableT && Callable &41;


className: TTaskDelegate< ReturnType(ParamTypes...), TotalSize >::~TTaskDelegate


code: template<uint32 TotalSize, typename ReturnType, typename... ParamTypes> class TTaskDelegate< ReturnType(ParamTypes...), TotalSize >


className: PointerType

code: typedef Type * PointerType


code: template<typename Type, uint32 NumItems> class TWorkStealingQueue2 : protected [LowLevelTasks::LocalQueue_Impl::TWorkStealingQueueBase2< NumItems >](API\Runtime\Core\Async\Fundamental\TWorkStealingQueueBase2)


className: ESlotState

code: enum ESlotState { Free = 0, Taken = 1, }


description: Remove an item at the head position in FIFO order (this can only safe on a single thread, shared with Put)

code: bool Get ( uintptr_t & Item )


description: Insert an item at the head position (this can only safe on a single thread, shared with Get)

code: bool Put ( uintptr_t Item )


description: Remove an item at the tail position in LIFO order (this can be done from any thread including the one that accesses the head)

code: bool Steal ( uintptr_t & Item )


code: template<uint32 NumItems> class TWorkStealingQueueBase2


description: Template for setting a promise value from a continuation.

code: namespace FutureDetail { template<typename Func, typename ParamType, typename ResultType> void FutureDetail::SetPromiseValue ( [TPromise](API\Runtime\Core\Async\TPromise)< ResultType > & Promise, Func & Function, [TFuture](API\Runtime\Core\Async\TFuture)< ParamType > && Param ) }


code: namespace FutureDetail { template<typename Func, typename ParamType> void FutureDetail::SetPromiseValue ( [TPromise](API\Runtime\Core\Async\TPromise)< void > & Promise, Func & Function, [TFuture](API\Runtime\Core\Async\TFuture)< ParamType > && Param ) }


code: FWaitingScope ( const [TArray](API\Runtime\Core\Containers\TArray)< [FId](API\Runtime\Core\Async\FId) > & Tasks )


code: FWaitingScope ( [FId](API\Runtime\Core\Async\FId) TaskId )


className: FWaitState

code: struct FWaitState

bDidWait

type: bool

description: Did this thread wait? True only if CanWait returned true.

bDidWake

description: Did this wake from a wait? True only if a Wake call woke the thread, false for timeouts.

WakeToken

description: Optional value that was provided by the callback in WakeOne.


className: FWakeState

code: struct FWakeState

bDidWake

description: Did a thread wake up?

bHasWaitingThreads

description: Does the queue have another thread waiting?


className: IsLockedFlag

code: static constexpr UPTRINT IsLockedFlag = 1 << 0;


className: IsQueueLockedFlag

code: static constexpr UPTRINT IsQueueLockedFlag = 1 << 1;


code: [FWordMutex](API\Runtime\Core\Async\FWordMutex) & operator= ( const [FWordMutex](API\Runtime\Core\Async\FWordMutex) & )


className: QueueMask

code: static constexpr UPTRINT QueueMask = ~(IsLockedFlag | IsQueueLockedFlag);


code: FWordMutex ( const [FWordMutex](API\Runtime\Core\Async\FWordMutex) & )


description: GetStatusText

code: [TOptional](API\Runtime\Core\IO\TOptional)< float > GetCompletion()


description: GetCompletion


className: FWordMutex

description: PreferFMutextoFWordMutexwhenever possible. This mutex is not fair and does not support recursive locking.

code: class FWordMutex


description: A delegate that is executed if the task's progress changed.

code: FSimpleDelegate & OnProgressChanged()


description: Virtual destructor.

code: virtual ~IAsyncProgress()


className: IAsyncProgress

description: Interface for checking the progress of asynchronous tasks.

code: class IAsyncProgress


code: [IAsyncReadFileHandle](API\Runtime\Core\Async\IAsyncReadFileHandle) & operator= ( const [IAsyncReadFileHandle](API\Runtime\Core\Async\IAsyncReadFileHandle) & )


description:
Submit an async request and/or wait for an async request
A request for the read. This is owned by the caller and must be deleted by the caller.

code: [IAsyncReadRequest](API\Runtime\Core\Async\IAsyncReadRequest) * ReadRequest ( int64 Offset, int64 BytesToRead, EAsyncIOPriorityAndFlags PriorityAndFlags, FAsyncFileCallBack * CompleteCallback, uint8 * UserSuppliedMemory )


description: Minimizes buffers held internally by this handle.

code: virtual void ShrinkHandleBuffers()


description:
Request the size of the file. This is also essentially the existence check.
A request for the size. This is owned by the caller and must be deleted by the caller.

code: [IAsyncReadRequest](API\Runtime\Core\Async\IAsyncReadRequest) * SizeRequest ( FAsyncFileCallBack * CompleteCallback )


description: Return true if this file is backed by a cache, if not, then precache requests are ignored.

code: virtual bool UsesCache()


description: Non-copyable.

code: IAsyncReadFileHandle ( const [IAsyncReadFileHandle](API\Runtime\Core\Async\IAsyncReadFileHandle) & )


description: Destructor, also the only way to close the file handle. It is not legal to delete an async file with outstanding requests. You must always call WaitCompletion before deleting a request.

code: virtual ~IAsyncReadFileHandle()


className: IAsyncReadFileHandle

code: class IAsyncReadFileHandle


description: Cancel the request. This is a non-blocking async call and so does not ensure completion!

code: void Cancel()


code: void CancelImpl()


description:
Return the bytes of a completed read request. Not legal to call unless the request is complete.
Returned memory block which if non-null contains the bytes read. Caller owns the memory block and must callFMemory::Freeon it when done. Can be null if the file was not found or could not be read or the request was cancelled, or the request had AIOP_FLAG_PRECACHE.

code: uint8 * GetReadResults()


description:
Return the size of a completed size request. Not legal to call unless the request is complete.
Returned size of the file or -1 if the file was not found, the request was canceled or other error.

code: int64 GetSizeResults()


description:
Nonblocking poll of the state of completion.
true if the request is complete

code: bool PollCompletion()


description: Transfer ownership of Memory from the async request to the outside caller (called in response to GetReadResults). It's only relevant to Read requests, in which case the most common use is to update (decrease) the STAT_AsyncFileMemory stat which is typically incremented when async requests allocate Memory. It doesn't play any role in Size requests, so it may be left empty for them.

code: void ReleaseMemoryOwnershipImpl()


description:
Waits for the request to complete, but not longer than the given time limit
true if the request is complete

code: bool WaitCompletion ( float TimeLimitSeconds )


code: void WaitCompletionImpl ( float TimeLimitSeconds )


code: IAsyncReadRequest ( FAsyncFileCallBack * InCallback, bool bInSizeRequest, uint8 * UserSuppliedMemory )


description: Not legal to destroy the request until it is complete.

code: virtual ~IAsyncReadRequest()


className: IAsyncReadRequest

code: class IAsyncReadRequest

type: union IAsyncRea...

bSizeRequest

type: const bool

Callback

type: FAsyncFileCallB...

Memory

type: uint8 *

Size

type: PTRINT


description: If the task is already running, it should make a best effort to abort execution as soon as possible. This method should be implemented in such a way that it returns immediately and does not block the caller.


description:
Gets the current state of the task.
Task state.

code: EAsyncTaskState GetTaskState()


description: Virtual destructor.

code: virtual ~IAsyncTask()


className: IAsyncTask

description: A asynchronous task is a unit of work that runs in parallel to the caller and may take a considerable amount of time to complete, i.e. several seconds, minutes or even hours. This interface provides mechanisms for tracking and canceling such tasks.

code: class IAsyncTask


description: Return the size of the mapped file.

code: int64 GetFileSize() const


description:
Map a region of the file.
the mapped region interface. Returns nullptr on failure.

code: [IMappedFileRegion](API\Runtime\Core\Async\IMappedFileRegion) * MapRegion ( int64 Offset, int64 BytesToMap, bool bPreloadHint )


code: [IMappedFileHandle](API\Runtime\Core\Async\IMappedFileHandle) & operator= ( const [IMappedFileHandle](API\Runtime\Core\Async\IMappedFileHandle) & )


code: IMappedFileHandle ( size_t InFileSize )


description: Non-copyable.

code: IMappedFileHandle ( const [IMappedFileHandle](API\Runtime\Core\Async\IMappedFileHandle) & )


code: virtual ~IMappedFileHandle()


className: IMappedFileHandle

code: class IMappedFileHandle


description:
Return the pointer to the mapped region.
Returned size of the file or -1 if the file was not found, the request was canceled or other error.

code: const uint8 * GetMappedPtr()


description: Return the size of the mapped region.

code: int64 GetMappedSize()


code: [IMappedFileRegion](API\Runtime\Core\Async\IMappedFileRegion) & operator= ( const [IMappedFileRegion](API\Runtime\Core\Async\IMappedFileRegion) & )


description: Synchronously preload part or all of the mapped region. Typically this is done by reading a byte from each CPU page. This is only a hint, some platforms might ignore it. There are not guarantees how long this data will stay in memory.

code: virtual void PreloadHint ( int64 PreloadOffset, int64 BytesToPreload )


code: IMappedFileRegion ( const uint8 * InMappedPtr, size_t InMappedSize, const [FString](API\Runtime\Core\Containers\FString) & InDebugFilename, size_t InDebugOffsetRelativeToFile )


description: Non-copyable.

code: IMappedFileRegion ( const [IMappedFileRegion](API\Runtime\Core\Async\IMappedFileRegion) & )


className: IMappedFileRegion

code: class IMappedFileRegion


description: Helper to call body with context reference.

code: namespace ParallelForImpl { template<typename FunctionType, typename ContextType> void ParallelForImpl::CallBody ( const FunctionType & Body, const [TArrayView](API\Runtime\Core\Containers\TArrayView)< ContextType > & Contexts, int32 TaskIndex, int32 Index ) }


description: Helper specialization for "no context", which changes the assumed body call signature.

code: namespace ParallelForImpl { template<typename FunctionType> void ParallelForImpl::CallBody ( const FunctionType & Body, const [TArrayView](API\Runtime\Core\Containers\TArrayView)< TYPE_OF_NULLPTR > &, int32, int32 Index ) }


code: namespace ParallelForImpl { int32 ParallelForImpl::GetNumberOfThreadTasks ( int32 Num, int32 MinBatchSize, EParallelForFlags Flags ) }


description: General purpose parallel for that uses the taskgraph

code: namespace ParallelForImpl { template<typename BodyType, typename PreWorkType, typename ContextType> void ParallelForImpl::ParallelForInternal ( const TCHAR * DebugName, int32 Num, int32 MinBatchSize, BodyType Body, PreWorkType CurrentThreadWorkToDoBeforeHelping, EParallelForFlags Flags, const [TArrayView](API\Runtime\Core\Containers\TArrayView)< ContextType > & Contexts ) }


code: namespace TaskTrace { void TaskTrace::Completed ( [FId](API\Runtime\Core\Async\FId) TaskId ) }


code: namespace TaskTrace { void TaskTrace::Created ( [FId](API\Runtime\Core\Async\FId) TaskId, uint64 TaskSize ) }


code: namespace TaskTrace { void TaskTrace::Destroyed ( [FId](API\Runtime\Core\Async\FId) TaskId ) }


code: namespace TaskTrace { void TaskTrace::Finished ( [FId](API\Runtime\Core\Async\FId) TaskId ) }


description: NOOP implementation.

code: namespace TaskTrace { [FId](API\Runtime\Core\Async\FId) TaskTrace::GenerateTaskId() }


description: Initialize buffer size.

code: namespace TaskTrace { void TaskTrace::Init() }


code: namespace TaskTrace { void TaskTrace::Scheduled ( [FId](API\Runtime\Core\Async\FId) TaskId ) }


code: namespace TaskTrace { void TaskTrace::Launched ( [FId](API\Runtime\Core\Async\FId) TaskId, const TCHAR * DebugName, bool bTracked, [ENamedThreads::Type](API\Runtime\Core\Async\ENamedThreads__Type) ThreadToExecuteOn, uint64 TaskSize ) }


code: namespace TaskTrace { void TaskTrace::Started ( [FId](API\Runtime\Core\Async\FId) TaskId ) }


code: namespace TaskTrace { void TaskTrace::SubsequentAdded ( [FId](API\Runtime\Core\Async\FId) TaskId, [FId](API\Runtime\Core\Async\FId) SubsequentId ) }


description: Performs the actual task.

code: void DoTask ( [ENamedThreads::Type](API\Runtime\Core\Async\ENamedThreads__Type) CurrentThread, const FGraphEventRef & MyCompletionGraphEvent )


description:
Returns the name of the thread that this task should run on.
Always run on any thread.


description:
Gets the future that will hold the asynchronous result.
ATFutureobject.

code: [TFuture](API\Runtime\Core\Async\TFuture)< ResultType > GetFuture()


description: Creates and initializes a new instance.

code: TAsyncGraphTask ( [TUniqueFunction](API\Runtime\Core\Templates\TUniqueFunction)< ResultType()> && InFunction, [TPromise](API\Runtime\Core\Async\TPromise)< ResultType > && InPromise, [ENamedThreads::Type](API\Runtime\Core\Async\ENamedThreads__Type) InDesiredThread )


className: TAsyncGraphTask

description: Template for asynchronous functions that are executed in the Task Graph system.

code: template<typename ResultType> class TAsyncGraphTask : public [FAsyncGraphTaskBase](API\Runtime\Core\Async\FAsyncGraphTaskBase)


description: Tells the queued work that it is being abandoned so that it can do per object clean up as needed. This will only be called if it is being abandoned before completion. NOTE: This requires the object to delete itself using whatever heap it was allocated in.

code: virtual void Abandon()


description: This is where the real thread work is done. All work that is done for this queued object should be done from within the call to this function.

code: virtual void DoThreadedWork()


description: Creates and initializes a new instance.

code: TAsyncQueuedWork ( [TUniqueFunction](API\Runtime\Core\Templates\TUniqueFunction)< ResultType()> && InFunction, [TPromise](API\Runtime\Core\Async\TPromise)< ResultType > && InPromise )


className: TAsyncQueuedWork

description: Template for asynchronous functions that are executed in the queued thread pool.

code: template<typename ResultType> class TAsyncQueuedWork : public [IQueuedWork](API\Runtime\Core\Misc\IQueuedWork)


description:
Gets the future that will hold the result.
The future.

code: const [TFuture](API\Runtime\Core\Async\TFuture)< ResultType > & GetFuture() const


description:
Get an object that indicates the progress of the task that is computing the result.
Task progress object, or nullptr if not available.

code: [TSharedPtr](API\Runtime\Core\Templates\TSharedPtr)< [IAsyncProgress](API\Runtime\Core\Async\IAsyncProgress) > GetProgess() const


description:
Get the asynchronous task that is computing the result.
Task object, or nullptr if not available.

code: [TSharedPtr](API\Runtime\Core\Templates\TSharedPtr)< [IAsyncTask](API\Runtime\Core\Async\IAsyncTask) > GetTask() const


description: Move assignment operator.

code: [TAsyncResult](API\Runtime\Core\Async\TAsyncResult) & operator= ( [TAsyncResult](API\Runtime\Core\Async\TAsyncResult) && Other )


description: Hidden copy assignment (async results cannot be copied).

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


description: Default constructor.

code: TAsyncResult()


description: Move constructor.

code: TAsyncResult ( [TAsyncResult](API\Runtime\Core\Async\TAsyncResult) && Other )


description: Creates and initializes a new instance with the given synchronous result value. This constructor is only available for referenceable result types, to make 'void' a feasible result type for this template class.

code: template<typename ArgType, typename> TAsyncResult ( const ArgType & Result )


description: Hidden copy constructor (async results cannot be copied).

code: TAsyncResult &40; const TAsyncResult & &41;


description: Creates and initializes a new instance

code: TAsyncResult ( [TFuture](API\Runtime\Core\Async\TFuture)< ResultType > && InFuture, const [TSharedPtr](API\Runtime\Core\Templates\TSharedPtr)< [IAsyncProgress](API\Runtime\Core\Async\IAsyncProgress) > & InProgress, const [TSharedPtr](API\Runtime\Core\Templates\TSharedPtr)< [IAsyncTask](API\Runtime\Core\Async\IAsyncTask) > & InTask )


className: TAsyncResult

description: Template for asynchronous return values.

code: template<typename ResultType> class TAsyncResult


description: Exit

code: virtual uint32 Run()


description: Creates and initializes a new instance.

code: TAsyncRunnable ( [TUniqueFunction](API\Runtime\Core\Templates\TUniqueFunction)< ResultType()> && InFunction, [TPromise](API\Runtime\Core\Async\TPromise)< ResultType > && InPromise, [TFuture](API\Runtime\Core\Async\TFuture)< [FRunnableThread](API\Runtime\Core\HAL\FRunnableThread) * > && InThreadFuture )


className: TAsyncRunnable

description: Template for asynchronous functions that are executed in a separate thread.

code: template<typename ResultType> class TAsyncRunnable : public [FRunnable](API\Runtime\Core\HAL\FRunnable)


className: TDynamicUniqueLock::operator bool

code: operator bool() const


code: [TDynamicUniqueLock](API\Runtime\Core\Async\TDynamicUniqueLock) & operator= ( const [TDynamicUniqueLock](API\Runtime\Core\Async\TDynamicUniqueLock) & )


code: [TDynamicUniqueLock](API\Runtime\Core\Async\TDynamicUniqueLock) & operator= ( [TDynamicUniqueLock](API\Runtime\Core\Async\TDynamicUniqueLock) && Other )


code: TDynamicUniqueLock ( const [TDynamicUniqueLock](API\Runtime\Core\Async\TDynamicUniqueLock) & )


code: TDynamicUniqueLock ( LockType & Lock )


code: TDynamicUniqueLock ( [TDynamicUniqueLock](API\Runtime\Core\Async\TDynamicUniqueLock) && Other )


code: TDynamicUniqueLock ( LockType & Lock, [FDeferLock](API\Runtime\Core\Async\FDeferLock) )


className: TDynamicUniqueLock

code: template<typename LockType> class TDynamicUniqueLock


description: Any threads that have calledPrepareWait()and not yet waited will be notified immediately if they do wait on a token from a call toPrepareWait()that preceded this call.

code: void Notify()


code: [TEventCount](API\Runtime\Core\Async\TEventCount) & operator= ( const [TEventCount](API\Runtime\Core\Async\TEventCount) & )


description:
Call this before any logic that must re-execute if the event is notified in the meantime.
A token to pass to one of the wait functions to abort the wait if the event has been notified since.

code: [TEventCountToken](API\Runtime\Core\Async\TEventCountToken)< CounterType > PrepareWait()


description:
Wait until the event is notified. Returns immediately if notified since the token was acquired.
True if the event was notified before the wait time elapsed, otherwise false.

code: bool WaitFor ( [TEventCountToken](API\Runtime\Core\Async\TEventCountToken)< CounterType > Compare, [FMonotonicTimeSpan](API\Runtime\Core\Misc\FMonotonicTimeSpan) WaitTime )


code: bool WaitUntil ( [TEventCountToken](API\Runtime\Core\Async\TEventCountToken)< CounterType > Compare, [FMonotonicTimePoint](API\Runtime\Core\Misc\FMonotonicTimePoint) WaitTime )


code: TEventCount ( const [TEventCount](API\Runtime\Core\Async\TEventCount) & )


className: TEventCount

description: Acquiring a token before checking the condition avoids a race because Wait returns immediately when the token no longer matches the notification count.

code: template<typename CounterType> class TEventCount


className: TEventCountToken::operator bool

description: Returns true if the token has been assigned by PrepareWait().


description: Wait until the event is notified. Returns immediately if notified since the token was acquired.

code: void Wait ( [TEventCountToken](API\Runtime\Core\Async\TEventCountToken)< CounterType > Compare )


className: TEventCountToken

description: A token used to wait onTEventCount.

code: template<typename CounterType> class TEventCountToken


code: void DoTask ( [ENamedThreads::Type](API\Runtime\Core\Async\ENamedThreads__Type) CurrentThread, const FGraphEventRef & MyCompletionGraphEvent )


description: Task constructor

code: TFunctionGraphTaskImpl ( [TUniqueFunction](API\Runtime\Core\Templates\TUniqueFunction)< Signature > && InFunction, [TStatId](API\Runtime\Core\Stats\TStatId) StatId, [ENamedThreads::Type](API\Runtime\Core\Async\ENamedThreads__Type) InDesiredThread )


className: TFunctionGraphTaskImpl

description: Task class for lambda based tasks.

code: template<typename Signature, [ESubsequentsMode::Type](API\Runtime\Core\Async\ESubsequentsMode__Type) SubsequentsMode> class TFunctionGraphTaskImpl : public [FCustomStatIDGraphTaskBase](API\Runtime\Core\Async\FCustomStatIDGraphTaskBase)


className: BaseType

code: typedef [TFutureBase](API\Runtime\Core\Async\TFutureBase)< ResultType > BaseType


description:
Gets the future's result.
The result.

code: ResultType Get() const


description: Move assignment operator.

code: [TFuture](API\Runtime\Core\Async\TFuture) & operator= ( [TFuture](API\Runtime\Core\Async\TFuture) && Other )


description: Hidden copy assignment (futures cannot be copied).

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


description:
Moves this future's state into a shared future.
The shared future object.

code: [TSharedFuture](API\Runtime\Core\Async\TSharedFuture)< ResultType > Share()


description: Default constructor.

code: TFuture()


description: Creates and initializes a new instance.

code: TFuture ( const typename [BaseType::StateType](API\Runtime\Core\Async\TFutureBase\StateType) & InState )


description: Move constructor.

code: TFuture ( [TFuture](API\Runtime\Core\Async\TFuture) && )


description: Hidden copy constructor (futures cannot be copied).

code: TFuture &40; const TFuture & &41;


description: Destructor.

code: ~TFuture()


description:
Gets the shared state object.
The shared state object.

code: const [StateType](API\Runtime\Core\Async\TFutureBase\StateType) & GetState() const


className: TFuture

description: TFuture< ResultType & >TFuture< void >

code: template<typename ResultType> class TFuture : public [TFutureBase< ResultType >](API\Runtime\Core\Async\TFutureBase)


description: IsValid

code: bool IsReady() const


description: IsReady

code: bool IsValid() const


description:
Convenience wrapper for Then that set a completion callback that will be called once the future completes or immediately if already completed
nothing at the moment but could return another future to allow future chaining

code: template<typename Func> auto Next ( Func Continuation )


description: Protected move assignment

code: [TFutureBase](API\Runtime\Core\Async\TFutureBase) & operator= ( [TFutureBase](API\Runtime\Core\Async\TFutureBase) && )


description: Protected copy assignment

code: [TFutureBase](API\Runtime\Core\Async\TFutureBase) & operator= ( const [TFutureBase](API\Runtime\Core\Async\TFutureBase) & )


description: Reset the future. Reseting a future removes any continuation from its shared state and invalidates it. Useful for discarding yet to be completed future cleanly.

code: void Reset()


className: StateType

code: typedef [TSharedPtr](API\Runtime\Core\Templates\TSharedPtr)< [TFutureState](API\Runtime\Core\Async\TFutureState)< InternalResultType >, ESPMode::ThreadSafe > StateType


description:
Set a completion callback that will be called once the future completes or immediately if already completed
nothing at the moment but could return another future to allow future chaining

code: template<typename Func> auto Then ( Func Continuation )


description: WaitUntil

code: void Wait() const


description: WaitUntil

code: bool WaitFor ( const [FTimespan](API\Runtime\Core\Misc\FTimespan) & Duration ) const


description: WaitUntil

code: bool WaitUntil ( const [FDateTime](API\Runtime\Core\Misc\FDateTime) & Time ) const


description: Default constructor.

code: TFutureBase()


description: Creates and initializes a new instance.

code: TFutureBase ( const [StateType](API\Runtime\Core\Async\TFutureBase\StateType) & InState )


description: Protected move construction

code: TFutureBase ( [TFutureBase](API\Runtime\Core\Async\TFutureBase) && )


description: Protected copy construction

code: TFutureBase ( const [TFutureBase](API\Runtime\Core\Async\TFutureBase) & )


description: Protected destructor.

code: ~TFutureBase()


className: TFutureBase

description: TFutureAbstract base template for futures and shared futures.

code: template<typename InternalResultType> class TFutureBase


description: GetResult

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


description: Default constructor.

code: TFutureState()


description: EmplaceResult

code: const InternalResultType & GetResult() const


description: Create and initialize a new instance with a callback.

code: TFutureState ( [TUniqueFunction](API\Runtime\Core\Templates\TUniqueFunction)< void()> && CompletionCallback )


className: TFutureState

description: Implements the internal state of asynchronous return values (futures).

code: template<typename InternalResultType> class TFutureState : public [FFutureState](API\Runtime\Core\Async\FFutureState)


code: typedef TFutureBase< ResultType &42; > BaseType


className: TFuture< ResultType & >::Get

description:
Gets the future's result.
The result.

code: ResultType & Get&40;&41; const


className: TFuture< ResultType & >::operator=

description: Move assignment operator.

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


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


className: TFuture< ResultType & >::Share

code: TSharedFuture< ResultType & > Share&40;&41;


className: TFuture< ResultType & >::TFuture

description: Default constructor.


description: Creates and initializes a new instance.

code: TFuture &40; const typename BaseType::StateType & InState &41;


code: TFuture &40; const TFuture & &41;


description: Move constructor.

code: TFuture &40; TFuture && &41;


className: TFuture< ResultType & >::~TFuture

description: Destructor.


className: TFuture< ResultType & >

description: Template for unshared futures (specialization for reference types).

code: template<typename ResultType> class TFuture< ResultType & > : public [TFutureBase< ResultType * >](API\Runtime\Core\Async\TFutureBase)


code: typedef TFutureBase< int > BaseType


className: TFuture< void >::Get

description:
Gets the future's result.
The result.

code: void Get&40;&41; const


className: TFuture< void >::operator=

description: Move assignment operator.