code: template<typename UserClass, typename... VarTypes> void BindUObject &40; TObjectPtr< UserClass > InUserObject, typename TMemFunPtrType< false, UserClass, RetValType(ParamTypes..., std::decay_t< VarTypes >...)>::Type InFunc, VarTypes &&... Vars &41;


className: TDelegate< InRetValType(ParamTypes...), UserPolicy >::BindUObject

module: Core

code: template<typename UserClass, typename... VarTypes> void BindUObject &40; TObjectPtr< UserClass > InUserObject, typename TMemFunPtrType< true, UserClass, RetValType(ParamTypes..., std::decay_t< VarTypes >...)>::Type InFunc, VarTypes &&... Vars &41;


className: TDelegate< InRetValType(ParamTypes...), UserPolicy >::BindWeakLambda

description: Static: Binds a weak object C++ lambda delegate technically this works for any functor types, but lambdas are the primary use case

code: template<typename UserClass, typename FunctorType, typename... VarTypes> void BindWeakLambda &40; UserClass &42; InUserObject, FunctorType && InFunctor, VarTypes &&... Vars &41;


className: TDelegate< InRetValType(ParamTypes...), UserPolicy >::CreateLambda

description: Static: Creates a C++ lambda delegate technically this works for any functor types, but lambdas are the primary use case

code: template<typename FunctorType, typename... VarTypes> static TDelegate< RetValType(ParamTypes...), UserPolicy > CreateLambda &40; FunctorType && InFunctor, VarTypes &&... Vars &41;


className: TDelegate< InRetValType(ParamTypes...), UserPolicy >::CreateRaw

description: Raw pointer doesn't use any sort of reference, so may be unsafe to call if the object was deleted out from underneath your delegate. Be careful when callingExecute()!

code: template<typename UserClass, typename... VarTypes> static TDelegate< RetValType(ParamTypes...), UserPolicy > CreateRaw &40; UserClass &42; InUserObject, typename TMemFunPtrType< false, UserClass, RetValType(ParamTypes..., std::decay_t< VarTypes >...)>::Type InFunc, VarTypes &&... Vars &41;


code: template<typename UserClass, typename... VarTypes> static TDelegate< RetValType(ParamTypes...), UserPolicy > CreateRaw &40; const UserClass &42; InUserObject, typename TMemFunPtrType< true, UserClass, RetValType(ParamTypes..., std::decay_t< VarTypes >...)>::Type InFunc, VarTypes &&... Vars &41;


className: TDelegate< InRetValType(ParamTypes...), UserPolicy >::CreateSP

description: Shared pointer delegates keep a weak reference to your object. You can useExecuteIfBound()to call them.

code: template<typename UserClass, ESPMode Mode, typename... VarTypes> static TDelegate< RetValType(ParamTypes...), UserPolicy > CreateSP &40; const TSharedRef< UserClass, Mode > & InUserObjectRef, typename TMemFunPtrType< false, UserClass, RetValType(ParamTypes..., std::decay_t< VarTypes >...)>::Type InFunc, VarTypes &&... Vars &41;


code: template<typename UserClass, ESPMode Mode, typename... VarTypes> static TDelegate< RetValType(ParamTypes...), UserPolicy > CreateSP &40; const TSharedRef< UserClass, Mode > & InUserObjectRef, typename TMemFunPtrType< true, UserClass, RetValType(ParamTypes..., std::decay_t< VarTypes >...)>::Type InFunc, VarTypes &&... Vars &41;


code: template<typename UserClass, typename... VarTypes> static TDelegate< RetValType(ParamTypes...), UserPolicy > CreateSP &40; UserClass &42; InUserObject, typename TMemFunPtrType< false, UserClass, RetValType(ParamTypes..., std::decay_t< VarTypes >...)>::Type InFunc, VarTypes &&... Vars &41;


code: template<typename UserClass, typename... VarTypes> static TDelegate< RetValType(ParamTypes...), UserPolicy > CreateSP &40; const UserClass &42; InUserObject, typename TMemFunPtrType< true, UserClass, RetValType(ParamTypes..., std::decay_t< VarTypes >...)>::Type InFunc, VarTypes &&... Vars &41;


className: TDelegate< InRetValType(ParamTypes...), UserPolicy >::CreateSPLambda

description: Static: Creates a weak shared pointer C++ lambda delegate technically this works for any functor types, but lambdas are the primary use case

code: template<typename UserClass, ESPMode Mode, typename FunctorType, typename... VarTypes> static TDelegate< RetValType(ParamTypes...), UserPolicy > CreateSPLambda &40; const TSharedRef< UserClass, Mode > & InUserObjectRef, FunctorType && InFunctor, VarTypes &&... Vars &41;


code: template<typename UserClass, typename FunctorType, typename... VarTypes> static TDelegate< RetValType(ParamTypes...), UserPolicy > CreateSPLambda &40; UserClass &42; InUserObject, FunctorType && InFunctor, VarTypes &&... Vars &41;


className: TDelegate< InRetValType(ParamTypes...), UserPolicy >::CreateStatic

description: Static: Creates a raw C++ pointer global function delegate

code: template<typename... VarTypes> static TDelegate< RetValType(ParamTypes...), UserPolicy > CreateStatic &40; typename TIdentity< RetValType(&42;)(ParamTypes..., std::decay_t< VarTypes >...)>::Type InFunc, VarTypes &&... Vars &41;


className: TDelegate< InRetValType(ParamTypes...), UserPolicy >::CreateThreadSafeSP

description: Note: This function is redundant, but is retained for backwards compatibility.CreateSP()works in both thread-safe and not-thread-safe modes and should be preferred.

code: template<typename UserClass, typename... VarTypes> static TDelegate< RetValType(ParamTypes...), UserPolicy > CreateThreadSafeSP &40; const TSharedRef< UserClass, ESPMode::ThreadSafe > & InUserObjectRef, typename TMemFunPtrType< false, UserClass, RetValType(ParamTypes..., std::decay_t< VarTypes >...)>::Type InFunc, VarTypes &&... Vars &41;


code: template<typename UserClass, typename... VarTypes> static TDelegate< RetValType(ParamTypes...), UserPolicy > CreateThreadSafeSP &40; const UserClass &42; InUserObject, typename TMemFunPtrType< true, UserClass, RetValType(ParamTypes..., std::decay_t< VarTypes >...)>::Type InFunc, VarTypes &&... Vars &41;


code: template<typename UserClass, typename... VarTypes> static TDelegate< RetValType(ParamTypes...), UserPolicy > CreateThreadSafeSP &40; const TSharedRef< UserClass, ESPMode::ThreadSafe > & InUserObjectRef, typename TMemFunPtrType< true, UserClass, RetValType(ParamTypes..., std::decay_t< VarTypes >...)>::Type InFunc, VarTypes &&... Vars &41;


code: template<typename UserClass, typename... VarTypes> static TDelegate< RetValType(ParamTypes...), UserPolicy > CreateThreadSafeSP &40; UserClass &42; InUserObject, typename TMemFunPtrType< false, UserClass, RetValType(ParamTypes..., std::decay_t< VarTypes >...)>::Type InFunc, VarTypes &&... Vars &41;


className: TDelegate< InRetValType(ParamTypes...), UserPolicy >::CreateUFunction

description: UFunctiondelegates keep a weak reference to your object. You can useExecuteIfBound()to call them.

code: template<typename UObjectTemplate, typename... VarTypes> static TDelegate< RetValType(ParamTypes...), UserPolicy > CreateUFunction &40; UObjectTemplate &42; InUserObject, const FName & InFunctionName, VarTypes &&... Vars &41;


code: template<typename UObjectTemplate, typename... VarTypes> static TDelegate< RetValType(ParamTypes...), UserPolicy > CreateUFunction &40; TObjectPtr< UObjectTemplate > InUserObject, const FName & InFunctionName, VarTypes &&... Vars &41;


className: TDelegate< InRetValType(ParamTypes...), UserPolicy >::CreateUObject

description: UObjectdelegates keep a weak reference to your object. You can useExecuteIfBound()to call them.

code: template<typename UserClass, typename... VarTypes> static TDelegate< RetValType(ParamTypes...), UserPolicy > CreateUObject &40; UserClass &42; InUserObject, typename TMemFunPtrType< false, UserClass, RetValType(ParamTypes..., std::decay_t< VarTypes >...)>::Type InFunc, VarTypes &&... Vars &41;


code: template<typename UserClass, typename... VarTypes> static TDelegate< RetValType(ParamTypes...), UserPolicy > CreateUObject &40; TObjectPtr< UserClass > InUserObject, typename TMemFunPtrType< false, UserClass, RetValType(ParamTypes..., std::decay_t< VarTypes >...)>::Type InFunc, VarTypes &&... Vars &41;


code: template<typename UserClass, typename... VarTypes> static TDelegate< RetValType(ParamTypes...), UserPolicy > CreateUObject &40; const UserClass &42; InUserObject, typename TMemFunPtrType< true, UserClass, RetValType(ParamTypes..., std::decay_t< VarTypes >...)>::Type InFunc, VarTypes &&... Vars &41;


code: template<typename UserClass, typename... VarTypes> static TDelegate< RetValType(ParamTypes...), UserPolicy > CreateUObject &40; TObjectPtr< UserClass > InUserObject, typename TMemFunPtrType< true, UserClass, RetValType(ParamTypes..., std::decay_t< VarTypes >...)>::Type InFunc, VarTypes &&... Vars &41;


className: TDelegate< InRetValType(ParamTypes...), UserPolicy >::CreateWeakLambda

description: Static: Creates a weak object C++ lambda delegate technically this works for any functor types, but lambdas are the primary use case

code: template<typename UserClass, typename FunctorType, typename... VarTypes> static TDelegate< RetValType(ParamTypes...), UserPolicy > CreateWeakLambda &40; UserClass &42; InUserObject, FunctorType && InFunctor, VarTypes &&... Vars &41;


className: DelegateInstanceInterfaceType

code: typedef IBaseDelegateInstance< FuncType, UserPolicy > DelegateInstanceInterfaceType


className: TDelegate< InRetValType(ParamTypes...), UserPolicy >::Execute

description: ExecuteIfBound

code: RetValType Execute &40; ParamTypes... Params &41; const


className: TDelegate< InRetValType(ParamTypes...), UserPolicy >::ExecuteIfBound

description:
Execute the delegate, but only if the function pointer is still valid
Returns true if the function was executed

code: template<typename DummyRetValType, std::enable_if_t< std::is_void< DummyRetValType >::value > &42;> bool ExecuteIfBound &40; ParamTypes... Params &41; const


className: TDelegate< InRetValType(ParamTypes...), UserPolicy >::GetDelegateInstanceProtected

description: Returns a pointer to the correctly-typed delegate instance.


code: const DelegateInstanceInterfaceType &42; GetDelegateInstanceProtected&40;&41; const


className: TDelegate< InRetValType(ParamTypes...), UserPolicy >::operator=

code: TDelegate & operator&61; &40; const TDelegate & Other &41;


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


className: RetValType

description: Type definition for return value type.

code: typedef InRetValType RetValType


className: Super

code: typedef typename UserPolicy::FDelegateExtras Super


className: TConstMethodPtr

code: typedef typename TMemFunPtrType< true, UserClass, RetValType(ParamTypes..., VarTypes...)>::Type TConstMethodPtr


className: TDelegate< InRetValType(ParamTypes...), UserPolicy >::TDelegate

code: TDelegate &40; TYPE_OF_NULLPTR &41;


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


code: TDelegate &40; TDelegate && Other &41;


description: Copying from delegates with different user policy

code: template<typename OtherUserPolicy> TDelegate &40; const TDelegate< FuncType, OtherUserPolicy > & Other &41;


className: TFuncPtr

description: Helper typedefs for getting a member function pointer type for the delegate with a given payload

code: typedef RetValType(&42;)(ParamTypes..., VarTypes...) TFuncPtr


className: TFuncType

code: typedef InRetValType TFuncType


className: TMethodPtr

code: typedef typename TMemFunPtrType< false, UserClass, RetValType(ParamTypes..., VarTypes...)>::Type TMethodPtr


code: template<typename InRetValType, typename... ParamTypes, typename UserPolicy> class TDelegate< InRetValType(ParamTypes...), UserPolicy > : public FDelegateExtras


className: TIntegerSequence

code: template<typename T, T... Indices> struct TIntegerSequence


className: TMakeIntegerSequenceImpl

code: template<typename T, unsigned N> struct TMakeIntegerSequenceImpl


className: TMemFunPtrType

description: TMemFunPtrType< false, Class, RetType(ArgTypes...)>TMemFunPtrType< true, Class, RetType(ArgTypes...)>

code: template<bool Const, typename Class, typename FuncType> struct TMemFunPtrType


className: Type

code: typedef RetType(Class::&42; Type


code: template<typename Class, typename RetType, typename... ArgTypes> struct TMemFunPtrType< false, Class, RetType(ArgTypes...)>


code: template<typename Class, typename RetType, typename... ArgTypes> struct TMemFunPtrType< true, Class, RetType(ArgTypes...)>


code: template<typename RetValType, typename... ParamTypes, typename UserPolicy> class TMulticastDelegate< RetValType(ParamTypes...), UserPolicy >


className: TMulticastDelegate

code: template<typename DelegateSignature, typename UserPolicy> class TMulticastDelegate


description: Adds the given delegate instance to the invocation list.

code: template<typename NewDelegateType> [FDelegateHandle](API\Runtime\Core\Delegates\FDelegateHandle) AddDelegateInstance ( NewDelegateType && NewDelegateBaseRef )


code: template<typename DelegateInstanceInterfaceType, typename... ParamTypes> void Broadcast ( ParamTypes... Params ) const


description: Removes all functions from this delegate's invocation list.

code: void Clear()


code: template<typename DelegateInstanceInterfaceType> void CopyFrom ( const [TMulticastDelegateBase](API\Runtime\Core\Delegates\TMulticastDelegateBase) & Other )


description: Returns the amount of memory allocated by this delegate's invocation list and the delegates stored within it, not including sizeof(*this).

code: SIZE_T GetAllocatedSize() const


description:
Checks to see if any functions are bound to this multi-cast delegate.
true if any functions are bound, false otherwise.

code: bool IsBound() const


description:
Checks to see if any functions are bound to the given user object.
True if any functions are bound to InUserObject, false otherwise.

code: bool IsBoundToObject ( void const * InUserObject ) const


code: [TMulticastDelegateBase](API\Runtime\Core\Delegates\TMulticastDelegateBase) & operator= ( [TMulticastDelegateBase](API\Runtime\Core\Delegates\TMulticastDelegateBase) && Other )


description:
Removes all functions from this multi-cast delegate's invocation list that are bound to the specified UserObject. Note that the order of the delegates may not be preserved!
The number of delegates successfully removed.

code: int32 RemoveAll ( const void * InUserObject )


description:
Removes a function from this multi-cast delegate's invocation list (performance is O(N)).
true if the delegate was successfully removed.

code: bool RemoveDelegateInstance ( [FDelegateHandle](API\Runtime\Core\Delegates\FDelegateHandle) Handle )


code: typedef [TDelegateAccessHandlerBase](API\Runtime\Core\Delegates\TDelegateAccessHandlerBase)< typename UserPolicy::FThreadSafetyMode > Super


className: UnicastDelegateType

description: Individual bindings are not checked for races as it's done for the parent delegate

code: typedef [TDelegateBase](API\Runtime\Core\Delegates\TDelegateBase)< FNotThreadSafeNotCheckedDelegateMode > UnicastDelegateType


description: Hidden default constructor.

code: TMulticastDelegateBase()


code: TMulticastDelegateBase ( [TMulticastDelegateBase](API\Runtime\Core\Delegates\TMulticastDelegateBase) && Other )


className: TMulticastDelegateBase

description: Abstract base class for multicast delegates.

code: template<typename UserPolicy> class TMulticastDelegateBase : public [TDelegateAccessHandlerBase< UserPolicy::FThreadSafetyMode >](API\Runtime\Core\Delegates\TDelegateAccessHandlerBase)


className: TMulticastDelegate< void(ParamTypes...), UserPolicy >::Add

description: Adds a delegate instance to this multicast delegate's invocation list.

code: FDelegateHandle Add &40; FDelegate && InNewDelegate &41;


code: FDelegateHandle Add &40; const FDelegate & InNewDelegate &41;


className: TMulticastDelegate< void(ParamTypes...), UserPolicy >::AddLambda

description: Adds a C++ lambda delegate technically this works for any functor types, but lambdas are the primary use case

code: template<typename FunctorType, typename... VarTypes> FDelegateHandle AddLambda &40; FunctorType && InFunctor, VarTypes &&... Vars &41;


className: TMulticastDelegate< void(ParamTypes...), UserPolicy >::AddRaw

description: Raw pointer doesn't use any sort of reference, so may be unsafe to call if the object was deleted out from underneath your delegate. Be careful when callingExecute()!

code: template<typename UserClass, typename... VarTypes> FDelegateHandle AddRaw &40; UserClass &42; InUserObject, typename TMemFunPtrType< false, UserClass, void(ParamTypes..., std::decay_t< VarTypes >...)>::Type InFunc, VarTypes &&... Vars &41;


code: template<typename UserClass, typename... VarTypes> FDelegateHandle AddRaw &40; const UserClass &42; InUserObject, typename TMemFunPtrType< true, UserClass, void(ParamTypes..., std::decay_t< VarTypes >...)>::Type InFunc, VarTypes &&... Vars &41;


className: TMulticastDelegate< void(ParamTypes...), UserPolicy >::AddSP

description: Shared pointer delegates keep a weak reference to your object.

code: template<typename UserClass, ESPMode Mode, typename... VarTypes> FDelegateHandle AddSP &40; const TSharedRef< UserClass, Mode > & InUserObjectRef, typename TMemFunPtrType< false, UserClass, void(ParamTypes..., std::decay_t< VarTypes >...)>::Type InFunc, VarTypes &&... Vars &41;


code: template<typename UserClass, ESPMode Mode, typename... VarTypes> FDelegateHandle AddSP &40; const TSharedRef< UserClass, Mode > & InUserObjectRef, typename TMemFunPtrType< true, UserClass, void(ParamTypes..., std::decay_t< VarTypes >...)>::Type InFunc, VarTypes &&... Vars &41;


code: template<typename UserClass, typename... VarTypes> FDelegateHandle AddSP &40; const UserClass &42; InUserObject, typename TMemFunPtrType< true, UserClass, void(ParamTypes..., std::decay_t< VarTypes >...)>::Type InFunc, VarTypes &&... Vars &41;


code: template<typename UserClass, typename... VarTypes> FDelegateHandle AddSP &40; UserClass &42; InUserObject, typename TMemFunPtrType< false, UserClass, void(ParamTypes..., std::decay_t< VarTypes >...)>::Type InFunc, VarTypes &&... Vars &41;


className: TMulticastDelegate< void(ParamTypes...), UserPolicy >::AddSPLambda

description: Adds a weak shared pointer C++ lambda delegate technically this works for any functor types, but lambdas are the primary use case

code: template<typename UserClass, typename FunctorType, typename... VarTypes> FDelegateHandle AddSPLambda &40; const UserClass &42; InUserObject, FunctorType && InFunctor, VarTypes &&... Vars &41;


className: TMulticastDelegate< void(ParamTypes...), UserPolicy >::AddThreadSafeSP

description: Note: This function is redundant, but is retained for backwards compatibility.AddSP()works in both thread-safe and not-thread-safe modes and should be preferred.

code: template<typename UserClass, typename... VarTypes> FDelegateHandle AddThreadSafeSP &40; const TSharedRef< UserClass, ESPMode::ThreadSafe > & InUserObjectRef, typename TMemFunPtrType< false, UserClass, void(ParamTypes..., std::decay_t< VarTypes >...)>::Type InFunc, VarTypes &&... Vars &41;


className: TMulticastDelegate< void(ParamTypes...), UserPolicy >::AddStatic

description: Adds a raw C++ pointer global function delegate

code: template<typename... VarTypes> FDelegateHandle AddStatic &40; typename TBaseStaticDelegateInstance< void(ParamTypes...), UserPolicy, std::decay_t< VarTypes >... >::FFuncPtr InFunc, VarTypes &&... Vars &41;


code: template<typename UserClass, typename... VarTypes> FDelegateHandle AddThreadSafeSP &40; const TSharedRef< UserClass, ESPMode::ThreadSafe > & InUserObjectRef, typename TMemFunPtrType< true, UserClass, void(ParamTypes..., std::decay_t< VarTypes >...)>::Type InFunc, VarTypes &&... Vars &41;


code: template<typename UserClass, typename... VarTypes> FDelegateHandle AddThreadSafeSP &40; UserClass &42; InUserObject, typename TMemFunPtrType< false, UserClass, void(ParamTypes..., std::decay_t< VarTypes >...)>::Type InFunc, VarTypes &&... Vars &41;


className: TMulticastDelegate< void(ParamTypes...), UserPolicy >::AddUFunction

description: UFunctiondelegates keep a weak reference to your object.

code: template<typename UObjectTemplate, typename... VarTypes> FDelegateHandle AddUFunction &40; UObjectTemplate &42; InUserObject, const FName & InFunctionName, VarTypes &&... Vars &41;


code: template<typename UserClass, typename... VarTypes> FDelegateHandle AddThreadSafeSP &40; const UserClass &42; InUserObject, typename TMemFunPtrType< true, UserClass, void(ParamTypes..., std::decay_t< VarTypes >...)>::Type InFunc, VarTypes &&... Vars &41;


code: template<typename UObjectTemplate, typename... VarTypes> FDelegateHandle AddUFunction &40; TObjectPtr< UObjectTemplate > InUserObject, const FName & InFunctionName, VarTypes &&... Vars &41;


className: TMulticastDelegate< void(ParamTypes...), UserPolicy >::AddUObject

code: template<typename UserClass, typename... VarTypes> FDelegateHandle AddUObject &40; const UserClass &42; InUserObject, typename TMemFunPtrType< true, UserClass, void(ParamTypes..., std::decay_t< VarTypes >...)>::Type InFunc, VarTypes &&... Vars &41;


description: UObjectdelegates keep a weak reference to your object.

code: template<typename UserClass, typename... VarTypes> FDelegateHandle AddUObject &40; UserClass &42; InUserObject, typename TMemFunPtrType< false, UserClass, void(ParamTypes..., std::decay_t< VarTypes >...)>::Type InFunc, VarTypes &&... Vars &41;


code: template<typename UserClass, typename... VarTypes> FDelegateHandle AddUObject &40; TObjectPtr< UserClass > InUserObject, typename TMemFunPtrType< false, UserClass, void(ParamTypes..., std::decay_t< VarTypes >...)>::Type InFunc, VarTypes &&... Vars &41;


className: TMulticastDelegate< void(ParamTypes...), UserPolicy >::AddWeakLambda

description: Adds a weak object C++ lambda delegate technically this works for any functor types, but lambdas are the primary use case

code: template<typename UserClass, typename FunctorType, typename... VarTypes> FDelegateHandle AddWeakLambda &40; UserClass &42; InUserObject, FunctorType && InFunctor, VarTypes &&... Vars &41;


code: template<typename UserClass, typename... VarTypes> FDelegateHandle AddUObject &40; TObjectPtr< UserClass > InUserObject, typename TMemFunPtrType< true, UserClass, void(ParamTypes..., std::decay_t< VarTypes >...)>::Type InFunc, VarTypes &&... Vars &41;


className: TMulticastDelegate< void(ParamTypes...), UserPolicy >::Broadcast

description: The constness of this method is a lie, but it allows for broadcasting from const functions.

code: void Broadcast &40; ParamTypes... Params &41; const


className: DelegateInstanceInterfaceType

code: typedef IBaseDelegateInstance< void(ParamTypes...), UserPolicy > DelegateInstanceInterfaceType


className: FDelegate

description: Type definition for unicast delegate classes whose delegate instances are compatible with this delegate.

code: typedef TDelegate< void(ParamTypes...), UserPolicy > FDelegate


className: InvocationListType

code: typedef typename Super::InvocationListType InvocationListType


className: TMulticastDelegate< void(ParamTypes...), UserPolicy >::operator=

code: TMulticastDelegate & operator&61; &40; const TMulticastDelegate & Other &41;


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


className: TMulticastDelegate< void(ParamTypes...), UserPolicy >::TMulticastDelegate


className: TMulticastDelegate< void(ParamTypes...), UserPolicy >::Remove

description:
Note that the order of the delegate instances may not be preserved!
true if the delegate was successfully removed.

code: bool Remove &40; FDelegateHandle Handle &41;


className: Super

code: typedef typename UserPolicy::FMulticastDelegateExtras Super


code: TMulticastDelegate &40; TMulticastDelegate && &41;


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


code: template<typename... ParamTypes, typename UserPolicy> class TMulticastDelegate< void(ParamTypes...), UserPolicy > : public FMulticastDelegateExtras


description: : OBJPTR: There is a risk that theFObjectPtris storing a reference to the wrong type. This could happen if data was serialized at a time when a pointer field was declared to be of type A, but then the declaration changed and the pointer field is now of type B. Upon deserialization of pre-existing data, we'll be holding a reference to the wrong type of object which we'll just send back static_casted as the wrong type. Doing a check or checkSlow here could catch this, but it would be better if the check could happen elsewhere that isn't called as frequently.

code: T * Get() const


className: ElementType

description: TObjectPtrshould only be used on types T that are EITHER:

code: typedef T ElementType


code: [UClass](API\Runtime\CoreUObject\UObject\UClass) * GetClass() const


code: [FString](API\Runtime\Core\Containers\FString) GetFullName ( EObjectFullNameFlags Flags ) const


code: [TObjectPtr](API\Runtime\Core\Delegates\TObjectPtr)< [UObject](API\Runtime\CoreUObject\UObject\UObject) > GetOuter() const


code: [TObjectPtr](API\Runtime\Core\Delegates\TObjectPtr)< [UPackage](API\Runtime\CoreUObject\UObject\UPackage) > GetPackage() const


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


code: bool IsA ( const [UClass](API\Runtime\CoreUObject\UObject\UClass) * SomeBase ) const


description: Deprecated* IsNull is deprecated, please use operator bool instead. if (!MyObjectPtr) { ... }

code: bool IsNull() const


description: Deprecated* IsNullNoResolve is deprecated, please use operator bool instead. if (!MyObjectPtr) { ... }

code: bool IsNullNoResolve() const


className: TObjectPtr::operator bool

code: operator bool() const


className: TObjectPtr::operator T *

code: operator T *() const


className: TObjectPtr::operator T *&

code: operator T *&()


className: TObjectPtr::operator UPTRINT

code: operator UPTRINT() const


code: [TObjectPtr](API\Runtime\Core\Delegates\TObjectPtr)< T > & operator= ( [TObjectPtr](API\Runtime\Core\Delegates\TObjectPtr)< T > && )


code: [TObjectPtr](API\Runtime\Core\Delegates\TObjectPtr)< T > & operator= ( const [TObjectPtr](API\Runtime\Core\Delegates\TObjectPtr)< T > & )


code: [TObjectPtr](API\Runtime\Core\Delegates\TObjectPtr)< T > & operator= ( TYPE_OF_NULLPTR )


code: template<typename U, decltype(ImplicitConv< T * >(std::declval< U * >()))*> [TObjectPtr](API\Runtime\Core\Delegates\TObjectPtr)< T > & operator= ( const [TObjectPtr](API\Runtime\Core\Delegates\TObjectPtr)< U > & Other )


className: TObjectPtr::operator U *

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


code: [TObjectPtr](API\Runtime\Core\Delegates\TObjectPtr)< T > & operator= ( [TPrivateObjectPtr](API\Runtime\CoreUObject\UObject\TPrivateObjectPtr)< T > && PrivatePtr )


description: Equality/Inequality comparisons against otherTObjectPtr.

code: template<typename U> bool operator== ( const [TObjectPtr](API\Runtime\Core\Delegates\TObjectPtr)< U > & Other ) const


description: Equality/Inequality comparisons against nullptr.

code: bool operator== ( TYPE_OF_NULLPTR ) const


description: Equality/Inequality comparisons against another type that can be implicitly converted to the pointer type kept in aTObjectPtr.

code: template<typename U, typename> bool operator== ( U && Other ) const


code: template<typename U> bool operator!= ( const [TObjectPtr](API\Runtime\Core\Delegates\TObjectPtr)< U > & Other ) const


code: template<typename U, std::enable_if_t< ![TIsTObjectPtr](API\Runtime\CoreUObject\Templates\TIsTObjectPtr)< std::decay_t< U >>::Value, decltype(ImplicitConv< T * >(std::declval< U >())) > *> [TObjectPtr](API\Runtime\Core\Delegates\TObjectPtr)< T > & operator= ( U && Object )


code: bool operator!= ( TYPE_OF_NULLPTR ) const


code: template<typename U, typename> bool operator!= ( U && Other ) const


code: void SerializePtrStructured ( [FStructuredArchiveSlot](API\Runtime\Core\Serialization\FStructuredArchiveSlot) Slot )


code: TObjectPtr ( [TPrivateObjectPtr](API\Runtime\CoreUObject\UObject\TPrivateObjectPtr)< T > && PrivatePtr )


code: TObjectPtr ( [TObjectPtr](API\Runtime\Core\Delegates\TObjectPtr)< T > && Other )


code: TObjectPtr ( const [TObjectPtr](API\Runtime\Core\Delegates\TObjectPtr)< T > & Other )


code: TObjectPtr ( [FObjectPtr](API\Runtime\CoreUObject\UObject\FObjectPtr) ObjPtr )


code: template<typename U, decltype(ImplicitConv< T * >(std::declval< U * >()))*> TObjectPtr ( const [TObjectPtr](API\Runtime\Core\Delegates\TObjectPtr)< U > & Other )


code: template<typename U, std::enable_if_t< ![TIsTObjectPtr](API\Runtime\CoreUObject\Templates\TIsTObjectPtr)< std::decay_t< U >>::Value, decltype(ImplicitConv< T * >(std::declval< U >())) > *> TObjectPtr ( U && Object )


className: TObjectPtr

description: This is useful for automatic replacement of raw pointers to support advanced cook-time dependency tracking and editor-time lazy load use cases. See UnrealObjectPtrTool for tooling to automatically replace raw pointer members with FObjectPtr/TObjectPtr members instead.

code: template<typename T> struct TObjectPtr

DebugPtr

type: T *

description: DebugPtr allows for easier dereferencing of a resolvedTObjectPtrin watch windows of debuggers.

ObjectPtr

type: FObjectPtr


className: TPayload< Ret(Types...)>::GetResult

code: Ret & GetResult&40;&41;


className: TPayload< Ret(Types...)>::TPayload

code: template<typename... ArgTypes> TPayload &40; ArgTypes &&... Args &41;


className: TPayload< void(Types...)>::TPayload


className: TPayload< Ret(Types...)>

code: template<typename Ret, typename... Types> struct TPayload< Ret(Types...)>

Values

type: TTuple< Types.....


className: TPayload< void(Types...)>::GetResult

code: void GetResult&40;&41;


className: TPayload

description: TPayload< Ret(Types...)>TPayload< void(Types...)>

code: template<typename FuncType> struct TPayload


className: TPayload< void(Types...)>

code: template<typename... Types> struct TPayload< void(Types...)>


code: template<typename... ArgTypes> T * operator() ( ArgTypes &&... Args )


className: TPlacementNewer

code: template<typename T> struct TPlacementNewer


className: TStaticFNameFromCharSequence

code: template<typename IntSeq> struct TStaticFNameFromCharSequence


className: TStrAfterLastDoubleColon

description: Example:TStrAfterLastDoubleColonType ==TIntegerSequence

code: template<typename T> struct TStrAfterLastDoubleColon


className: Type

code: typedef TTypedImpl< T >::template Inner< true, Chars... >::Type Type


className: Inner

code: template<bool Dummy, T... Chars> struct Inner


code: template<typename SecondMatch, T... Chars> struct Inner2


code: typedef TIntegerSequence< T, Chars... > Type


code: template<T... Chars> struct Inner2< TIntegerSequence< T >, Chars... >


code: typedef TIntegerSequence< T > Type


className: Inner< Dummy >

description: Without the dummy bool parameter, this would not compile, as full specializations of nested class templates is not allowed.

code: template<bool Dummy> struct Inner< Dummy >


code: typedef Inner< Dummy, Chars... >::Type Type


className: Inner< Dummy, Char, Chars... >

code: template<bool Dummy, T Char, T... Chars> struct Inner< Dummy, Char, Chars... >


code: typedef Inner2< typename Inner< Dummy, Chars... >::Type, Chars... >::Type Type


className: TTypedImpl

code: template<typename T> struct TTypedImpl


className: Inner< Dummy, ':', ':', Chars... >

code: template<bool Dummy, T... Chars> struct Inner< Dummy, ':', ':', Chars... >


className: TWeakBaseFunctorDelegateInstance< UserClass, RetValType(ParamTypes...), UserPolicy, FunctorType, VarTypes... >::CreateCopy

code: void CreateCopy &40; TDelegateBase< FThreadSafeDelegateMode > & Base &41; const


code: void CreateCopy &40; TDelegateBase< FNotThreadSafeDelegateMode > & Base &41; const


code: void CreateCopy &40; TDelegateBase< FNotThreadSafeNotCheckedDelegateMode > & Base &41; const


className: DelegateBaseType

code: typedef typename UserPolicy::FDelegateExtras DelegateBaseType


className: TWeakBaseFunctorDelegateInstance< UserClass, RetValType(ParamTypes...), UserPolicy, FunctorType, VarTypes... >::Execute

code: RetValType Execute &40; ParamTypes... Params &41; const


className: TWeakBaseFunctorDelegateInstance< UserClass, RetValType(ParamTypes...), UserPolicy, FunctorType, VarTypes... >::GetBoundProgramCounterForTimerManager


className: TWeakBaseFunctorDelegateInstance< UserClass, RetValType(ParamTypes...), UserPolicy, FunctorType, VarTypes... >::GetUObject

code: UObject &42; GetUObject&40;&41; const


className: TWeakBaseFunctorDelegateInstance< UserClass, RetValType(ParamTypes...), UserPolicy, FunctorType, VarTypes... >::GetObjectForTimerManager

code: const void &42; GetObjectForTimerManager&40;&41; const


className: TWeakBaseFunctorDelegateInstance< UserClass, RetValType(ParamTypes...), UserPolicy, FunctorType, VarTypes... >::HasSameObject

description: Deprecated.

code: bool HasSameObject &40; const void &42; InContextObject &41; const


className: TWeakBaseFunctorDelegateInstance< UserClass, RetValType(ParamTypes...), UserPolicy, FunctorType, VarTypes... >::IsCompactable

code: bool IsCompactable&40;&41; const


className: TWeakBaseFunctorDelegateInstance< UserClass, RetValType(ParamTypes...), UserPolicy, FunctorType, VarTypes... >::ExecuteIfSafe

code: bool ExecuteIfSafe &40; ParamTypes... Params &41; const


className: TWeakBaseFunctorDelegateInstance< UserClass, RetValType(ParamTypes...), UserPolicy, FunctorType, VarTypes... >::IsSafeToExecute

code: bool IsSafeToExecute&40;&41; const


className: Super

code: typedef TCommonDelegateInstanceState< RetValType(ParamTypes...), UserPolicy, VarTypes... > Super


className: TWeakBaseFunctorDelegateInstance< UserClass, RetValType(ParamTypes...), UserPolicy, FunctorType, VarTypes... >::TryGetBoundFunctionName


className: TWeakBaseFunctorDelegateInstance< UserClass, RetValType(ParamTypes...), UserPolicy, FunctorType, VarTypes... >::TWeakBaseFunctorDelegateInstance

code: template<typename InFunctorType, typename... InVarTypes> TWeakBaseFunctorDelegateInstance &40; UserClass &42; InContextObject, InFunctorType && InFunctor, InVarTypes &&... Vars &41;


description:
Returns the root function name from a string representing a member function pointer. Note: this function only returns a pointer to the substring and doesn't create a new string.
AnFNameof the member function name.

code: namespace UE { namespace Delegates { namespace Private { [FName](API\Runtime\Core\UObject\FName) UE::Delegates::Private::GetTrimmedMemberFunctionName ( const TCHAR * InMacroFunctionName ) } } }


code: template<typename UserClass, typename RetValType, typename... ParamTypes, typename UserPolicy, typename FunctorType, typename... VarTypes> class TWeakBaseFunctorDelegateInstance< UserClass, RetValType(ParamTypes...), UserPolicy, FunctorType, VarTypes... > : public [TCommonDelegateInstanceState< RetValType(ParamTypes...), UserPolicy, VarTypes... >](API\Runtime\Core\Delegates\TCommonDelegateInstanceState)


className: TWeakBaseFunctorDelegateInstance

description: TWeakBaseFunctorDelegateInstance< UserClass, RetValType(ParamTypes...), UserPolicy, FunctorType, VarTypes... >

code: template<typename UserClass, typename FuncType, typename UserPolicy, typename FunctorType, typename... VarTypes> class TWeakBaseFunctorDelegateInstance


code: namespace UE { namespace Delegates { namespace Private { constexpr bool UE::Delegates::Private::IsUObjectPtr ( const volatile [UObjectBase](API\Runtime\CoreUObject\UObject\UObjectBase) * ) } } }


code: namespace UE { namespace Delegates { namespace Private { constexpr bool UE::Delegates::Private::IsUObjectPtr ( ... ) } } }


description: AwaitableTask_Detail::MakeDummyValue< void >

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


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


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


code: template<typename TLock> void Wait ( TLock & Lock )


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


className: FConditionVariable

description: A one-byte portable condition variable. Gives the same decent performance everywhere.

code: class FConditionVariable


description: Await the Task Completion and get the result, this will assert if this is a Dummy Handle. Awaiting an initizialized but not launched task will run ('launch') it synchronously in the current thread. use BusyWaitUntilLaunched if you want to wait for launching the task on another thread.

code: ReturnType Await()


description: Busy wait until the Task is launched from another Thread, this can be useful if we want to build chained tasks. So that we can wait until the first task launched it, otherwise if we would Await the task directly it might be executed immediately and before the first task completes.

code: void BusyWaitUntilLaunched() const


description: Initialize a new Task now and Abandon previous work (if any) initialized Tasks can be awaited on, but they will run synchronous in this case

code: template<typename CallableT> void Init ( const TCHAR * DebugName, CallableT && Callable )


description: Initialize a new Task with given Priority now and Abandon previous work (if any) initialized Tasks can be awaited on, but they will run synchronous in this case

code: template<typename CallableT> void Init ( const TCHAR * DebugName, [LowLevelTasks::ETaskPriority](API\Runtime\Core\Async\Fundamental\LowLevelTasks__ETaskPriority) Priority, CallableT && Callable )


description: Initialize and Launch a Task

code: template<typename CallableT> bool InitAndLaunch ( const TCHAR * DebugName, CallableT && Callable )


description: Initialize and Launch a Task with given Priority

code: template<typename CallableT> bool InitAndLaunch ( const TCHAR * DebugName, [LowLevelTasks::ETaskPriority](API\Runtime\Core\Async\Fundamental\LowLevelTasks__ETaskPriority) Priority, CallableT && Callable )


description: Returns true if the Tasks completed.

code: bool IsCompleted() const


description: Returns true if the Task has been Launched.

code: bool IsLaunched() const


code: [ThisClass](API\Runtime\Core\Experimental\Async\TAwaitableTask) & operator= ( const [ThisClass](API\Runtime\Core\Experimental\Async\TAwaitableTask) & Other )


description: Does the TaskHandle hold a valid or Dummy Task?

code: bool IsValid() const


code: [ThisClass](API\Runtime\Core\Experimental\Async\TAwaitableTask) & operator= ( [ThisClass](API\Runtime\Core\Experimental\Async\TAwaitableTask) && Other )


description: Abandon the Task and freeing its memory if this is the last reference to it.

code: void Reset()


className: ThisClass

code: typedef [TAwaitableTask](API\Runtime\Core\Experimental\Async\TAwaitableTask)< ReturnType > ThisClass


className: TPromise

code: typedef [AwaitableTask_Detail::TPromise](API\Runtime\Core\Experimental\Async\TPromise)< R, C > TPromise


className: TPromiseVTable

code: typedef [AwaitableTask_Detail::TPromiseVTable](API\Runtime\Core\Experimental\Async\TPromiseVTable)< P > TPromiseVTable


className: TPromiseVTableBase

code: typedef [AwaitableTask_Detail::TPromiseVTableBase](API\Runtime\Core\Experimental\Async\TPromiseVTableBase)< R > TPromiseVTableBase


className: TPromiseVTableDummy

code: typedef [AwaitableTask_Detail::TPromiseVTableDummy](API\Runtime\Core\Experimental\Async\TPromiseVTableDummy)< R > TPromiseVTableDummy


description: Launches the Task for processing on a WorkerThread. The returntype will specify if the Task was Launched successfully (true) or if it might have been launched already (false)

code: bool TryLaunch()


code: TAwaitableTask ( const [ThisClass](API\Runtime\Core\Experimental\Async\TAwaitableTask) & Other )


code: TAwaitableTask ( [ThisClass](API\Runtime\Core\Experimental\Async\TAwaitableTask) && Other )


className: TAwaitableTask

description: Awaitable Tasks are very simple they only allow for Lauching and Awaiting a Task. They will try to run other work while awaiting the Result.

code: template<typename ReturnType> class TAwaitableTask


code: [TMultiUniqueLock](API\Runtime\Core\Experimental\Async\TMultiUniqueLock) & operator= ( const [TArray](API\Runtime\Core\Containers\TArray)< TLockType * > & )


code: [TMultiUniqueLock](API\Runtime\Core\Experimental\Async\TMultiUniqueLock) & operator= ( [TArray](API\Runtime\Core\Containers\TArray)< TLockType * > && )


code: TMultiUniqueLock ( const [TArray](API\Runtime\Core\Containers\TArray)< TLockType * > & Locks )


code: TMultiUniqueLock ( [TArray](API\Runtime\Core\Containers\TArray)< TLockType * > && Locks )


className: TMultiUniqueLock

description: LikeTUniqueLock, but acquires multiple locks and holds then until destruction. Acquires the locks in address order to prevent deadlocks if multiple threads are usingTMultiUniqueLockfor similar sets of locks.

code: template<typename TLockType> class TMultiUniqueLock


className: ReturnType

code: typedef TReturnType ReturnType


className: ThisType

code: typedef [TPromise](API\Runtime\Core\Experimental\Async\TPromise)< [ReturnType](API\Runtime\Core\Experimental\Async\TPromise\ReturnType), CallableType > ThisType


code: template<typename CallableT> TPromise ( const TCHAR * DebugName, [LowLevelTasks::ETaskPriority](API\Runtime\Core\Async\Fundamental\LowLevelTasks__ETaskPriority) Priority, CallableT && InCallable )


code: template<typename TReturnType, typename CallableType> class TPromise : public [AwaitableTask_Detail::FPromiseBase](API\Runtime\Core\Experimental\Async\FPromiseBase)


code: typedef typename PromiseType::ReturnType ReturnType


code: TPromiseVTable ( [FPromiseBase](API\Runtime\Core\Experimental\Async\FPromiseBase) * InPromise )


description: TheTPromiseVTableis used to type erase the PromiseType and therefore its lambda type

code: template<typename PromiseType> class TPromiseVTable : public [AwaitableTask_Detail::TPromiseVTableBase< PromiseType::ReturnType >](API\Runtime\Core\Experimental\Async\TPromiseVTableBase)


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


code: [TPromiseVTableBase](API\Runtime\Core\Experimental\Async\TPromiseVTableBase) & operator= ( const [TPromiseVTableBase](API\Runtime\Core\Experimental\Async\TPromiseVTableBase) & Other )


code: TPromiseVTableBase ( [FPromiseBase](API\Runtime\Core\Experimental\Async\FPromiseBase) * InPromise )


description: TheTPromiseVTableBasetype is used to move the vtable pointer out of the promise, where it otherwise could interfere the alignment of the Callable/Lambda.

code: template<typename ReturnType> class TPromiseVTableBase

Promise

type: FPromiseBase&#...


description: TheTPromiseVTableDummyis used with empty handles, this allows us to always call the virtual interface without nullpointer checks validation for launching and getting the result of empty taskhandles is done as well.

code: template<typename ReturnType> class TPromiseVTableDummy : public [AwaitableTask_Detail::TPromiseVTableBase< ReturnType >](API\Runtime\Core\Experimental\Async\TPromiseVTableBase)


className: TPromise< void, CallableType >::Finish

code: void Finish&40;&41;


className: TPromise< void, CallableType >::GetResult

code: void GetResult&40;&41;


className: TPromise< void, CallableType >::IsCompleted

code: bool IsCompleted&40;&41; const


className: TPromise< void, CallableType >::IsLaunched

code: bool IsLaunched&40;&41; const


className: TPromise< void, CallableType >::IncrementRefCount

code: void IncrementRefCount&40;&41;


code: typedef TPromise< void, CallableType > ThisType


className: TPromise< void, CallableType >::TPromise

code: TPromise &40; const TPromise & &41;


code: template<typename CallableT> TPromise &40; const TCHAR &42; DebugName, LowLevelTasks::ETaskPriority Priority, CallableT && InCallable &41;


className: TPromise< void, CallableType >::TryLaunch

code: bool TryLaunch&40;&41;


className: TPromise< void, CallableType >

code: template<typename CallableType> class TPromise< void, CallableType > : public [AwaitableTask_Detail::FPromiseBase](API\Runtime\Core\Experimental\Async\FPromiseBase)


code: [DequeueHazard](API\Runtime\Core\Experimental\Containers\DequeueHazard) & operator= ( [DequeueHazard](API\Runtime\Core\Experimental\Containers\DequeueHazard) && Other )


code: DequeueHazard ( [DequeueHazard](API\Runtime\Core\Experimental\Containers\DequeueHazard) && Hazard )


code: DequeueHazard &40; std::atomic< Node &42; > & Hazard, FHazardPointerCollection & Collection &41;


className: DequeueHazard

code: class DequeueHazard : private [THazardPointer< Node, true >](API\Runtime\Core\Experimental\Containers\THazardPointer)


code: [EnqueueHazard](API\Runtime\Core\Experimental\Containers\EnqueueHazard) & operator= ( [EnqueueHazard](API\Runtime\Core\Experimental\Containers\EnqueueHazard) && Other )


code: EnqueueHazard ( [EnqueueHazard](API\Runtime\Core\Experimental\Containers\EnqueueHazard) && Hazard )


code: EnqueueHazard &40; std::atomic< Node &42; > & Hazard, FHazardPointerCollection & Collection &41;


className: EnqueueHazard

code: class EnqueueHazard : private [THazardPointer< Node, true >](API\Runtime\Core\Experimental\Containers\THazardPointer)


code: bool operator== ( [FHashElementId](API\Runtime\Core\Experimental\Containers\FHashElementId) InHashElementId ) const


className: InvalidHash

code: static constexpr const [IntType](API\Runtime\Core\Experimental\Containers\FHashType\IntType) InvalidHash = (IntType(1)) << (sizeof(IntType) * 8 - 1);


code: bool operator== ( [FHashType](API\Runtime\Core\Experimental\Containers\FHashType) Other ) const


code: bool operator!= ( [FHashType](API\Runtime\Core\Experimental\Containers\FHashType) Other ) const


code: [FHazardDeleter](API\Runtime\Core\Experimental\Containers\FHazardDeleter) & operator= ( const [FHazardDeleter](API\Runtime\Core\Experimental\Containers\FHazardDeleter) & Other )


code: bool operator== ( const [FHazardDeleter](API\Runtime\Core\Experimental\Containers\FHazardDeleter) & Other ) const


code: FHazardDeleter ( const [FHazardDeleter](API\Runtime\Core\Experimental\Containers\FHazardDeleter) & Other )


className: FHazardDeleter

description: FHazardDeleteris used to erase the type of a class so that we can call the correct destructor

code: class FHazardDeleter

Pointer

type: void *


description: Grab a hazard pointer and once hazard is set the other threads leave it alone

code: template<bool Cached> FHazardRecord * Acquire()


description: Mark pointer for deletion

code: void Delete &40; const HazardPointer_Impl::FHazardDeleter & Deleter, int32 CollectLimit &41;


description: If we own the pointer

code: template<typename D> void Delete ( D * Pointer, int32 CollectLimit )


className: HazardChunkSize

code: static constexpr uint32 HazardChunkSize = 32;


className: FHazardPointerCollection

description: FHazardPointerCollectionis a collection that is used to aquire a Hazardpointer

code: class FHazardPointerCollection


code: bool casNext ( Node * cmp, Node * val )


className: Node

code: struct Node

deqidx

type: std::atomic< in...

items

type: std::atomic< T ...

next

type: std::atomic< No...


code: bool Contains ( IndexType Index ) const


description: Start with the first entry pre-filled and enqidx at 1.

code: Node ( T * item )


className: TFreeList

code: template<typename AllocatorType> class TFreeList


code: static constexpr int32 DEFAULT_INITIAL_SIZE = 1024;


description: Add an entry with the given Key to the hash table, will do nothing if the item already exists

code: void Emplace ( KeyType Key, ValueType Value, bool * bIsAlreadyInTable )


description: Find an entry in the hash table

code: void Find ( KeyType Key, ValueType * OutValue, bool * bIsAlreadyInTable ) const


code: void FindOrAdd ( KeyType Key, ValueType Value, bool * bIsAlreadyInTable )


description: Can only be called once, and only before any items have been added!

code: void Reserve ( int32 Count )


code: TGrowOnlyLockFreeHash ( [FMalloc](API\Runtime\Core\HAL\FMalloc) * InMalloc )


className: TGrowOnlyLockFreeHash

description: Besides cleanup of wasted tables, it might be useful to provide a function to clear a table. This would involve clearing the Key for all the elements in the table (but leaving the memory allocated), and can be done safely with active readers. It's not possible to safely remove individual items due to the need to potentially move other items, which would break an active reader that has already searched past a moved item. But in the case of removing all items, we don't care when a reader fails, it's expected that eventually all readers will fail, regardless of where they are searching. A clear function could be useful if a lot of the data you are caching is no longer used, and you want to reset the cache.

code: template<typename EntryType, typename KeyType, typename ValueType> class TGrowOnlyLockFreeHash


description: Use with care, because the Hazardpointer will not protect anymore and needs to be recreated

code: void Destroy()


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


code: [THazardPointer](API\Runtime\Core\Experimental\Containers\THazardPointer) & operator= ( [THazardPointer](API\Runtime\Core\Experimental\Containers\THazardPointer) && Other )


description: Retireing can be used to release the hazardpointer without reaquiring a new Hazardslot in the Collection

code: void Retire()


code: THazardPointer &40; const THazardPointer & &41;


code: THazardPointer ( [THazardPointer](API\Runtime\Core\Experimental\Containers\THazardPointer) && Other )


code: THazardPointer ( std::atomic< H * > & InHazard, [FHazardPointerCollection](API\Runtime\Core\Experimental\Containers\FHazardPointerCollection) & Collection )


className: THazardPointer

description: THazardPointeris used to keep an allocation alive until all threads that referenced it finished their access

code: template<typename H, bool Cached> class THazardPointer


className: ElementType

code: typedef TPair< const KeyType, ValueType > ElementType


className: FindValueType

code: typedef ValueType * FindValueType


className: FindValueTypeConst

code: typedef const ValueType * FindValueTypeConst


className: TKeyValue

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

code: template<typename KeyType, typename ValueType> class TKeyValue


code: typedef const KeyType ElementType


code: typedef const KeyType &42; FindValueType


className: TKeyValue< KeyType, FUnitType >

code: template<typename KeyType> class TKeyValue< KeyType, FUnitType >


className: Base

code: typedef typename [RobinHoodHashTable_Private::TRobinHoodHashTable](API\Runtime\Core\Experimental\Containers\TRobinHoodHashTable)< KeyType, ValueType, Hasher, HashMapAllocator > Base


code: [FindValueType](API\Runtime\Core\Experimental\Containers\TRobinHoodHashTable\FindValueType) FindOrAdd ( const KeyType & Key, const ValueType & Val )


code: [FindValueType](API\Runtime\Core\Experimental\Containers\TRobinHoodHashTable\FindValueType) FindOrAdd ( KeyType && Key, const ValueType & Val )


code: [FindValueType](API\Runtime\Core\Experimental\Containers\TRobinHoodHashTable\FindValueType) FindOrAdd ( const KeyType & Key, ValueType && Val )


code: [FindValueType](API\Runtime\Core\Experimental\Containers\TRobinHoodHashTable\FindValueType) FindOrAdd ( KeyType && Key, ValueType && Val )


code: [FindValueType](API\Runtime\Core\Experimental\Containers\TRobinHoodHashTable\FindValueType) FindOrAdd ( const KeyType & Key, const ValueType & Val, bool & bIsAlreadyInMap )


code: [FindValueType](API\Runtime\Core\Experimental\Containers\TRobinHoodHashTable\FindValueType) FindOrAdd ( const KeyType & Key, ValueType && Val, bool & bIsAlreadyInMap )


code: [FindValueType](API\Runtime\Core\Experimental\Containers\TRobinHoodHashTable\FindValueType) FindOrAdd ( KeyType && Key, ValueType && Val, bool & bIsAlreadyInMap )


code: [FHashElementId](API\Runtime\Core\Experimental\Containers\FHashElementId) FindOrAddId ( const KeyType & Key, const ValueType & Val )


code: [FHashElementId](API\Runtime\Core\Experimental\Containers\FHashElementId) FindOrAddId ( const KeyType & Key, ValueType && Val )


code: [FHashElementId](API\Runtime\Core\Experimental\Containers\FHashElementId) FindOrAddId ( KeyType && Key, const ValueType & Val )


code: [FHashElementId](API\Runtime\Core\Experimental\Containers\FHashElementId) FindOrAddId ( KeyType && Key, ValueType && Val )


code: [FHashElementId](API\Runtime\Core\Experimental\Containers\FHashElementId) FindOrAddId ( const KeyType & Key, const ValueType & Val, bool & bIsAlreadyInMap )


code: [FindValueType](API\Runtime\Core\Experimental\Containers\TRobinHoodHashTable\FindValueType) FindOrAdd ( KeyType && Key, const ValueType & Val, bool & bIsAlreadyInMap )


code: [FHashElementId](API\Runtime\Core\Experimental\Containers\FHashElementId) FindOrAddId ( const KeyType & Key, ValueType && Val, bool & bIsAlreadyInMap )


code: [FHashElementId](API\Runtime\Core\Experimental\Containers\FHashElementId) FindOrAddId ( KeyType && Key, const ValueType & Val, bool & bIsAlreadyInMap )


code: [FHashElementId](API\Runtime\Core\Experimental\Containers\FHashElementId) FindOrAddId ( KeyType && Key, ValueType && Val, bool & bIsAlreadyInMap )


code: [FHashElementId](API\Runtime\Core\Experimental\Containers\FHashElementId) FindOrAddIdByHash ( [FHashType](API\Runtime\Core\Experimental\Containers\FHashType) HashValue, const KeyType & Key, const ValueType & Val )


code: [FHashElementId](API\Runtime\Core\Experimental\Containers\FHashElementId) FindOrAddIdByHash ( [FHashType](API\Runtime\Core\Experimental\Containers\FHashType) HashValue, const KeyType & Key, ValueType && Val )


code: [FHashElementId](API\Runtime\Core\Experimental\Containers\FHashElementId) FindOrAddIdByHash ( [FHashType](API\Runtime\Core\Experimental\Containers\FHashType) HashValue, KeyType && Key, const ValueType & Val )


code: [FHashElementId](API\Runtime\Core\Experimental\Containers\FHashElementId) FindOrAddIdByHash ( [FHashType](API\Runtime\Core\Experimental\Containers\FHashType) HashValue, KeyType && Key, ValueType && Val )


code: [FHashElementId](API\Runtime\Core\Experimental\Containers\FHashElementId) FindOrAddIdByHash ( [FHashType](API\Runtime\Core\Experimental\Containers\FHashType) HashValue, const KeyType & Key, const ValueType & Val, bool & bIsAlreadyInMap )


code: [FHashElementId](API\Runtime\Core\Experimental\Containers\FHashElementId) FindOrAddIdByHash ( [FHashType](API\Runtime\Core\Experimental\Containers\FHashType) HashValue, const KeyType & Key, ValueType && Val, bool & bIsAlreadyInMap )


code: [FHashElementId](API\Runtime\Core\Experimental\Containers\FHashElementId) FindOrAddIdByHash ( [FHashType](API\Runtime\Core\Experimental\Containers\FHashType) HashValue, KeyType && Key, const ValueType & Val, bool & bIsAlreadyInMap )


code: [FHashElementId](API\Runtime\Core\Experimental\Containers\FHashElementId) FindOrAddIdByHash ( [FHashType](API\Runtime\Core\Experimental\Containers\FHashType) HashValue, KeyType && Key, ValueType && Val, bool & bIsAlreadyInMap )


code: typedef typename Base::FindValueType FindValueType


code: typedef typename Base::FindValueTypeConst FindValueTypeConst


className: IndexType

code: typedef typename Base::IndexType IndexType


code: [TRobinHoodHashMap](API\Runtime\Core\Experimental\Containers\TRobinHoodHashMap) & operator= ( const [TRobinHoodHashMap](API\Runtime\Core\Experimental\Containers\TRobinHoodHashMap) & Other )


code: [FindValueType](API\Runtime\Core\Experimental\Containers\TRobinHoodHashTable\FindValueType) Update ( const KeyType & Key, const ValueType & Val )


code: [FindValueType](API\Runtime\Core\Experimental\Containers\TRobinHoodHashTable\FindValueType) Update ( const KeyType & Key, ValueType && Val )


code: [FindValueType](API\Runtime\Core\Experimental\Containers\TRobinHoodHashTable\FindValueType) Update ( KeyType && Key, ValueType && Val )


code: [FindValueType](API\Runtime\Core\Experimental\Containers\TRobinHoodHashTable\FindValueType) Update ( KeyType && Key, const ValueType & Val )


code: [FindValueType](API\Runtime\Core\Experimental\Containers\TRobinHoodHashTable\FindValueType) Update ( const KeyType & Key, const ValueType & Val, bool & bIsAlreadyInMap )


code: [FindValueType](API\Runtime\Core\Experimental\Containers\TRobinHoodHashTable\FindValueType) Update ( const KeyType & Key, ValueType && Val, bool & bIsAlreadyInMap )


code: [FindValueType](API\Runtime\Core\Experimental\Containers\TRobinHoodHashTable\FindValueType) Update ( KeyType && Key, const ValueType & Val, bool & bIsAlreadyInMap )


code: [FindValueType](API\Runtime\Core\Experimental\Containers\TRobinHoodHashTable\FindValueType) Update ( KeyType && Key, ValueType && Val, bool & bIsAlreadyInMap )


code: [TRobinHoodHashMap](API\Runtime\Core\Experimental\Containers\TRobinHoodHashMap) & operator= ( [TRobinHoodHashMap](API\Runtime\Core\Experimental\Containers\TRobinHoodHashMap) && Other )


code: [FHashElementId](API\Runtime\Core\Experimental\Containers\FHashElementId) UpdateId ( const KeyType & Key, const ValueType & Val )


code: [FHashElementId](API\Runtime\Core\Experimental\Containers\FHashElementId) UpdateId ( KeyType && Key, const ValueType & Val )


code: [FHashElementId](API\Runtime\Core\Experimental\Containers\FHashElementId) UpdateId ( const KeyType & Key, ValueType && Val )


code: [FHashElementId](API\Runtime\Core\Experimental\Containers\FHashElementId) UpdateId ( KeyType && Key, ValueType && Val )


code: [FHashElementId](API\Runtime\Core\Experimental\Containers\FHashElementId) UpdateId ( const KeyType & Key, const ValueType & Val, bool & bIsAlreadyInMap )


code: [FHashElementId](API\Runtime\Core\Experimental\Containers\FHashElementId) UpdateId ( const KeyType & Key, ValueType && Val, bool & bIsAlreadyInMap )


code: [FHashElementId](API\Runtime\Core\Experimental\Containers\FHashElementId) UpdateId ( KeyType && Key, const ValueType & Val, bool & bIsAlreadyInMap )


code: [FHashElementId](API\Runtime\Core\Experimental\Containers\FHashElementId) UpdateId ( KeyType && Key, ValueType && Val, bool & bIsAlreadyInMap )


code: [FHashElementId](API\Runtime\Core\Experimental\Containers\FHashElementId) UpdateIdByHash ( [FHashType](API\Runtime\Core\Experimental\Containers\FHashType) HashValue, const KeyType & Key, const ValueType & Val )


code: [FHashElementId](API\Runtime\Core\Experimental\Containers\FHashElementId) UpdateIdByHash ( [FHashType](API\Runtime\Core\Experimental\Containers\FHashType) HashValue, const KeyType & Key, ValueType && Val )


code: [FHashElementId](API\Runtime\Core\Experimental\Containers\FHashElementId) UpdateIdByHash ( [FHashType](API\Runtime\Core\Experimental\Containers\FHashType) HashValue, KeyType && Key, const ValueType & Val )


code: [FHashElementId](API\Runtime\Core\Experimental\Containers\FHashElementId) UpdateIdByHash ( [FHashType](API\Runtime\Core\Experimental\Containers\FHashType) HashValue, KeyType && Key, ValueType && Val )


code: [FHashElementId](API\Runtime\Core\Experimental\Containers\FHashElementId) UpdateIdByHash ( [FHashType](API\Runtime\Core\Experimental\Containers\FHashType) HashValue, const KeyType & Key, const ValueType & Val, bool & bIsAlreadyInMap )


code: [FHashElementId](API\Runtime\Core\Experimental\Containers\FHashElementId) UpdateIdByHash ( [FHashType](API\Runtime\Core\Experimental\Containers\FHashType) HashValue, const KeyType & Key, ValueType && Val, bool & bIsAlreadyInMap )


code: [FHashElementId](API\Runtime\Core\Experimental\Containers\FHashElementId) UpdateIdByHash ( [FHashType](API\Runtime\Core\Experimental\Containers\FHashType) HashValue, KeyType && Key, const ValueType & Val, bool & bIsAlreadyInMap )


code: [FHashElementId](API\Runtime\Core\Experimental\Containers\FHashElementId) UpdateIdByHash ( [FHashType](API\Runtime\Core\Experimental\Containers\FHashType) HashValue, KeyType && Key, ValueType && Val, bool & bIsAlreadyInMap )


code: TRobinHoodHashMap ( const [TRobinHoodHashMap](API\Runtime\Core\Experimental\Containers\TRobinHoodHashMap) & Other )


code: TRobinHoodHashMap ( [TRobinHoodHashMap](API\Runtime\Core\Experimental\Containers\TRobinHoodHashMap) && Other )


code: typedef typename [RobinHoodHashTable_Private::TRobinHoodHashTable](API\Runtime\Core\Experimental\Containers\TRobinHoodHashTable)< KeyType, [Unit](API\Runtime\Core\Experimental\Containers\FUnitType), Hasher, HashMapAllocator > Base


className: TRobinHoodHashMap

code: template<typename KeyType, typename ValueType, typename Hasher, typename HashMapAllocator> class TRobinHoodHashMap : public [Experimental::RobinHoodHashTable_Private::TRobinHoodHashTable< KeyType, ValueType, Hasher, HashMapAllocator >](API\Runtime\Core\Experimental\Containers\TRobinHoodHashTable)


code: FindValueType FindOrAdd ( const KeyType & Key )


code: FindValueType FindOrAdd ( KeyType && Key )


code: FindValueType FindOrAdd ( const KeyType & Key, bool & bIsAlreadyInSet )


code: FindValueType FindOrAdd ( KeyType && Key, bool & bIsAlreadyInSet )


code: [FHashElementId](API\Runtime\Core\Experimental\Containers\FHashElementId) FindOrAddId ( const KeyType & Key )


code: [FHashElementId](API\Runtime\Core\Experimental\Containers\FHashElementId) FindOrAddId ( KeyType && Key )


code: [FHashElementId](API\Runtime\Core\Experimental\Containers\FHashElementId) FindOrAddId ( const KeyType & Key, bool & bIsAlreadyInSet )


code: [FHashElementId](API\Runtime\Core\Experimental\Containers\FHashElementId) FindOrAddId ( KeyType && Key, bool & bIsAlreadyInSet )


code: [FHashElementId](API\Runtime\Core\Experimental\Containers\FHashElementId) FindOrAddIdByHash ( [FHashType](API\Runtime\Core\Experimental\Containers\FHashType) HashValue, const KeyType & Key )


code: [FHashElementId](API\Runtime\Core\Experimental\Containers\FHashElementId) FindOrAddIdByHash ( [FHashType](API\Runtime\Core\Experimental\Containers\FHashType) HashValue, KeyType && Key )


code: [FHashElementId](API\Runtime\Core\Experimental\Containers\FHashElementId) FindOrAddIdByHash ( [FHashType](API\Runtime\Core\Experimental\Containers\FHashType) HashValue, KeyType && Key, bool & bIsAlreadyInSet )


code: [FHashElementId](API\Runtime\Core\Experimental\Containers\FHashElementId) FindOrAddIdByHash ( [FHashType](API\Runtime\Core\Experimental\Containers\FHashType) HashValue, const KeyType & Key, bool & bIsAlreadyInSet )


code: typedef typename Base::FindValueType FindValueType


code: typedef typename Base::FindValueTypeConst FindValueTypeConst


code: typedef typename Base::IndexType IndexType


code: [TRobinHoodHashSet](API\Runtime\Core\Experimental\Containers\TRobinHoodHashSet) & operator= ( [TRobinHoodHashSet](API\Runtime\Core\Experimental\Containers\TRobinHoodHashSet) && Other )


code: [TRobinHoodHashSet](API\Runtime\Core\Experimental\Containers\TRobinHoodHashSet) & operator= ( const [TRobinHoodHashSet](API\Runtime\Core\Experimental\Containers\TRobinHoodHashSet) & Other )


code: TRobinHoodHashSet ( const [TRobinHoodHashSet](API\Runtime\Core\Experimental\Containers\TRobinHoodHashSet) & Other )


code: TRobinHoodHashSet ( [TRobinHoodHashSet](API\Runtime\Core\Experimental\Containers\TRobinHoodHashSet) && Other )


className: TRobinHoodHashSet

code: template<typename KeyType, typename Hasher, typename HashMapAllocator> class TRobinHoodHashSet : public [Experimental::RobinHoodHashTable_Private::TRobinHoodHashTable< KeyType, RobinHoodHashTable_Private::FUnitType, Hasher, HashMapAllocator >](API\Runtime\Core\Experimental\Containers\TRobinHoodHashTable)


code: static [FHashType](API\Runtime\Core\Experimental\Containers\FHashType) ComputeHash ( const KeyType & Key )


code: bool ContainsElementId ( [FHashElementId](API\Runtime\Core\Experimental\Containers\FHashElementId) Id ) const


code: typedef typename [KeyValueType::ElementType](API\Runtime\Core\Misc\TTuple) ElementType


code: bool operator&61;&61; &40; const FConstIteratorType & Rhs &41; const


code: bool operator&33;&61; &40; const FConstIteratorType & Rhs &41; const


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


className: FConstIteratorType

code: class FConstIteratorType


code: template<typename DeducedKeyType, typename DeducedValueType> IndexType Allocate &40; DeducedKeyType && Key, DeducedValueType && Val, FHashType Hash &41;


code: bool Contains &40; IndexType Index &41; const


code: void Deallocate &40; IndexType Index &41;


code: bool operator&33;&61; &40; const FIteratorState & Rhs &41; const


code: bool operator&61;&61; &40; const FIteratorState & Rhs &41; const


className: FIteratorState

description:
operator==(
constFIteratorState& Rhs)

code: struct FIteratorState


code: const KeyValueType & Get &40; IndexType Index &41; const


code: KeyValueType & Get &40; IndexType Index &41;


code: SizeType GetAllocatedSize&40;&41; const


code: FIteratorState Next &40; FIteratorState State &41; const


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


code: void Reserve &40; SizeType ReserveNum &41;


className: FData

code: struct FData

FreeList

type: TFreeList<Inli...

Hashes

type: TArray<FHashTy...

KeyVals

type: TArray<KeyValu...


code: [FindValueType](API\Runtime\Core\Experimental\Containers\TRobinHoodHashTable\FindValueType) Find ( const KeyType & Key )


code: [FindValueTypeConst](API\Runtime\Core\Experimental\Containers\TRobinHoodHashTable\FindValueTypeConst) Find ( const KeyType & Key ) const


code: [FindValueType](API\Runtime\Core\Experimental\Containers\TRobinHoodHashTable\FindValueType) FindByHash ( const [FHashType](API\Runtime\Core\Experimental\Containers\FHashType) HashValue, const KeyType & Key )


code: const [FindValueType](API\Runtime\Core\Experimental\Containers\TRobinHoodHashTable\FindValueType) FindByHash ( const [FHashType](API\Runtime\Core\Experimental\Containers\FHashType) HashValue, const KeyType & Key ) const


code: [FHashElementId](API\Runtime\Core\Experimental\Containers\FHashElementId) FindId ( const KeyType & Key ) const


code: [FHashElementId](API\Runtime\Core\Experimental\Containers\FHashElementId) FindIdByHash ( const [FHashType](API\Runtime\Core\Experimental\Containers\FHashType) HashValue, const KeyType & ComparableKey ) const


code: template<typename DeducedKeyType, typename DeducedValueType> [FindValueType](API\Runtime\Core\Experimental\Containers\TRobinHoodHashTable\FindValueType) FindOrAdd ( DeducedKeyType && Key, DeducedValueType && Val, bool & bIsAlreadyInMap )


code: template<typename DeducedKeyType, typename DeducedValueType> [FHashElementId](API\Runtime\Core\Experimental\Containers\FHashElementId) FindOrAddId ( DeducedKeyType && Key, DeducedValueType && Val, bool & bIsAlreadyInMap )


code: template<typename DeducedKeyType, typename DeducedValueType> [FHashElementId](API\Runtime\Core\Experimental\Containers\FHashElementId) FindOrAddIdByHash ( [FHashType](API\Runtime\Core\Experimental\Containers\FHashType) HashValue, DeducedKeyType && Key, DeducedValueType && Val, bool & bIsAlreadyInMap )


code: typedef typename [KeyValueType::FindValueType](API\Runtime\Core\Math\TVector2) FindValueType


code: typedef typename [KeyValueType::FindValueTypeConst](API\Runtime\Core\Math\TVector2) FindValueTypeConst


code: bool operator&61;&61; &40; const FIteratorType & Rhs &41; const


code: bool operator&33;&61; &40; const FIteratorType & Rhs &41; const


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


className: FIteratorType

code: class FIteratorType


code: [ElementType](API\Runtime\Core\Experimental\Containers\TRobinHoodHashTable\ElementType) & GetByElementId ( [FHashElementId](API\Runtime\Core\Experimental\Containers\FHashElementId) Id )


code: const [ElementType](API\Runtime\Core\Experimental\Containers\TRobinHoodHashTable\ElementType) & GetByElementId ( [FHashElementId](API\Runtime\Core\Experimental\Containers\FHashElementId) Id ) const


className: InlineOneAllocatorType

code: typedef TInlineAllocator< 1, HashMapAllocator > InlineOneAllocatorType


code: void InsertIntoTable ( [IndexType](API\Runtime\Core\Experimental\Containers\TRobinHoodHashTable\IndexType) Index, [FHashType](API\Runtime\Core\Experimental\Containers\FHashType) Hash )


className: InvalidIndex

code: static constexpr const [IndexType](API\Runtime\Core\Experimental\Containers\TRobinHoodHashTable\IndexType) InvalidIndex = ~IndexType(0);


className: KeyValueType

code: typedef [RobinHoodHashTable_Private::TKeyValue](API\Runtime\Core\Experimental\Containers\TKeyValue)< KeyType, ValueType > KeyValueType


className: LoadFactorDivisor

code: static constexpr const [IndexType](API\Runtime\Core\Experimental\Containers\TRobinHoodHashTable\IndexType) LoadFactorDivisor = 3;


className: LoadFactorQuotient

code: static constexpr const [IndexType](API\Runtime\Core\Experimental\Containers\TRobinHoodHashTable\IndexType) LoadFactorQuotient = 5;


code: [IndexType](API\Runtime\Core\Experimental\Containers\TRobinHoodHashTable\IndexType) ModTableSize ( [IndexType](API\Runtime\Core\Experimental\Containers\TRobinHoodHashTable\IndexType) HashValue ) const


code: [TRobinHoodHashTable](API\Runtime\Core\Experimental\Containers\TRobinHoodHashTable) & operator= ( const [TRobinHoodHashTable](API\Runtime\Core\Experimental\Containers\TRobinHoodHashTable) & Other )


code: [TRobinHoodHashTable](API\Runtime\Core\Experimental\Containers\TRobinHoodHashTable) & operator= ( [TRobinHoodHashTable](API\Runtime\Core\Experimental\Containers\TRobinHoodHashTable) && Other )


code: bool RemoveByElementId ( [FHashElementId](API\Runtime\Core\Experimental\Containers\FHashElementId) Id )


code: void Reserve ( [SizeType](API\Runtime\Core\Experimental\Containers\TRobinHoodHashTable\SizeType) ReserveNum )


code: template<typename DeducedKeyType, typename DeducedValueType> [FindValueType](API\Runtime\Core\Experimental\Containers\TRobinHoodHashTable\FindValueType) Update ( DeducedKeyType && Key, DeducedValueType && Val, bool & bIsAlreadyInMap )


code: template<typename DeducedKeyType, typename DeducedValueType> [FHashElementId](API\Runtime\Core\Experimental\Containers\FHashElementId) UpdateId ( DeducedKeyType && Key, DeducedValueType && Val, bool & bIsAlreadyInMap )


code: template<typename DeducedKeyType, typename DeducedValueType> [FHashElementId](API\Runtime\Core\Experimental\Containers\FHashElementId) UpdateIdByHash ( [FHashType](API\Runtime\Core\Experimental\Containers\FHashType) HashValue, DeducedKeyType && Key, DeducedValueType && Val, bool & bIsAlreadyInMap )


code: TRobinHoodHashTable ( const [TRobinHoodHashTable](API\Runtime\Core\Experimental\Containers\TRobinHoodHashTable) & Other )


code: bool RemoveByHash ( const [FHashType](API\Runtime\Core\Experimental\Containers\FHashType) HashValue, const KeyType & ComparableKey )


code: TRobinHoodHashTable ( [TRobinHoodHashTable](API\Runtime\Core\Experimental\Containers\TRobinHoodHashTable) && Other )


className: TRobinHoodHashTable

code: template<typename KeyType, typename ValueType, typename Hasher, typename HashMapAllocator> class TRobinHoodHashTable


code: static uint32 GetKeyHash ( [KeyInitType](API\Runtime\Core\Experimental\Containers\TSherwoodHashKeyFuncs\KeyInitType) Key )


className: KeyInitType

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


className: TSherwoodHashKeyFuncs

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


code: static bool Matches ( [KeyInitType](API\Runtime\Core\Experimental\Containers\TSherwoodHashKeyFuncs\KeyInitType) A, [KeyInitType](API\Runtime\Core\Experimental\Containers\TSherwoodHashKeyFuncs\KeyInitType) B )


code: ValueType * Add ( int8 Distance, [FData](API\Runtime\Core\Experimental\Containers\TSherwoodHashTable\FData) & Data, uint32 Cursor, KeyType Key, [HashType](API\Runtime\Core\Experimental\Containers\TSherwoodHashTable\HashType) Hash, ValueType Value )


code: static [FData](API\Runtime\Core\Experimental\Containers\TSherwoodHashTable\FData) AllocateData ( uint32 Count )


code: template<typename T> static T * AllocateUninitialized ( uint32 Count )


className: bIsMap

description: TSherwoodHashTablecan be used to implement a set or a map. In map mode we allocate memory for keys and values, but in set mode we only allocate keys.

code: static constexpr bool bIsMap = !std::is_same_v<ValueType, FNoopStruct>;


code: static void Deallocate ( void * Ptr )


code: static void DeallocateData ( [FData](API\Runtime\Core\Experimental\Containers\TSherwoodHashTable\FData) & Data )


code: void AddAt &40; uint32 i, int8 InDistance, KeyType InKey, ValueType InValue &41;


code: bool HasValue &40; uint32 i &41; const


code: bool IsEmpty &40; uint32 i &41; const


code: static uint8 ComputeMaxLookups ( uint32 InNumSlots )


code: struct FData

Distances

type: int8 *

Keys

type: KeyType *

Values

type: ValueType *


code: [TTuple](API\Runtime\Core\Misc\TTuple)< const KeyType *, ValueType * > Find ( KeyType Key ) const


code: ValueType * FindOrAdd ( KeyType Key, ValueType Value, bool * bIsAlreadyInContainerPtr )


code: ValueType * FindOrAddByHash ( KeyType Key, [HashType](API\Runtime\Core\Experimental\Containers\TSherwoodHashTable\HashType) Hash, ValueType Value, bool * bIsAlreadyInContainerPtr )


className: MaxLoadFactor

description: Ratio between number of stored elements and allocated capacity beyond which the container will be grown (doubled in size).

code: static constexpr float MaxLoadFactor = 0.9f;


className: MinNumLookups

description: Minimum probing distance when searching for an entry slot.

code: static constexpr uint32 MinNumLookups = 4;


className: MinNumSlots

description: Smallest capacity of non-empty container.

code: static constexpr uint32 MinNumSlots = 4;


code: [TSherwoodHashTable](API\Runtime\Core\Experimental\Containers\TSherwoodHashTable) & operator= ( const [TSherwoodHashTable](API\Runtime\Core\Experimental\Containers\TSherwoodHashTable) & )


code: [TSherwoodHashTable](API\Runtime\Core\Experimental\Containers\TSherwoodHashTable) & operator= ( [TSherwoodHashTable](API\Runtime\Core\Experimental\Containers\TSherwoodHashTable) && )


code: void Reserve ( uint32 DesiredNumElements )


description: NOTE: Non-trivial type support, move and copy ops are not implemented yet, but can be.

code: TSherwoodHashTable()


code: void Rehash ( uint32 DesiredNumSlots )


code: TSherwoodHashTable ( [TSherwoodHashTable](API\Runtime\Core\Experimental\Containers\TSherwoodHashTable) && )


code: TSherwoodHashTable ( const [TSherwoodHashTable](API\Runtime\Core\Experimental\Containers\TSherwoodHashTable) & )


className: TSherwoodHashTable

description: Implementation of Robin Hood hash table based on sherwood_v3_table by Malte Skarupke. Good for small keys and values. If key is already a high quality hash, then identity hash function should be used. Current limitations:

code: template<typename KeyType, typename ValueType, typename KeyFuncs> struct TSherwoodHashTable

CurrentData

type: FData


code: const ValueType * Find ( KeyType Key ) const


code: ValueType & FindOrAdd ( KeyType Key, ValueType Value )


code: void Add ( KeyType Key, bool * bIsAlreadyInSetPtr )


className: TSherwoodMap

code: template<typename KeyType, typename ValueType, typename KeyFuncs> struct TSherwoodMap


code: const KeyType * Find ( KeyType Key ) const


className: TSherwoodSet

code: template<typename KeyType, typename KeyFuncs> struct TSherwoodSet


code: namespace CoroTask_Detail { [TDummyType](API\Runtime\Core\Experimental\Coroutine\TDummyType)< void > CoroTask_Detail::MakeDummyType() }


code: namespace CoroTask_Detail { template<typename T> auto CoroTask_Detail::MakeDummyType ( T && Value ) }


code: static [FCoroLocalState](API\Runtime\Core\Experimental\Coroutine\FCoroLocalState) & GetCoroLocalState()


code: static [FCoroLocalState](API\Runtime\Core\Experimental\Coroutine\FCoroLocalState) * SetCoroLocalState ( [FCoroLocalState](API\Runtime\Core\Experimental\Coroutine\FCoroLocalState) * )


code: FCoroLocalState ( const CoroTask_Detail::FPromise & InTaskOwner )


className: FCoroLocalState

code: class FCoroLocalState

CoroLocalStorage

type: TlsDictionaryTy...

TaskOwner

type: const CoroTask_...


className: FCoroLocalVariable

code: class FCoroLocalVariable


code: FCoroTimeoutAwaitable ( [FTimespan](API\Runtime\Core\Misc\FTimespan) InTimedelta, ECoroTimeoutFlags InFlags )


className: FCoroTimeoutAwaitable

code: class FCoroTimeoutAwaitable


className: TCoroLocal::operator bool

code: operator bool() const


code: [TCoroLocal](API\Runtime\Core\Experimental\Coroutine\TCoroLocal) & operator= ( const ValueType & Other )


className: VariableType

code: typedef [CoroTask_Detail::TCoroLocalVariable](API\Runtime\Core\Experimental\Coroutine\TCoroLocalVariable)< ValueType > VariableType


code: TCoroLocal ( ValueType && InDefaultValue )


className: TCoroLocal

description: TCoroLocalis an implementation of Coroutine Local State similar to TLS

code: template<typename ValueType> class TCoroLocal : private [CoroTask_Detail::FCoroLocal](API\Runtime\Core\Experimental\Coroutine\FCoroLocal)


code: TCoroLocalVariable ( const ValueType & DefaultValue )


className: TCoroLocalVariable

code: template<typename ValueType> class TCoroLocalVariable : public [CoroTask_Detail::FCoroLocalVariable](API\Runtime\Core\Experimental\Coroutine\FCoroLocalVariable)


code: [TDummyType](API\Runtime\Core\Experimental\Coroutine\TDummyType)< T > Launch ( const TCHAR * DebugName, [LowLevelTasks::ETaskPriority](API\Runtime\Core\Async\Fundamental\LowLevelTasks__ETaskPriority) Priority, [LowLevelTasks::EQueuePreference](API\Runtime\Core\Async\Fundamental\LowLevelTasks__EQueuePreference) QueuePreference, [LowLevelTasks::ETaskFlags](API\Runtime\Core\Async\Fundamental\LowLevelTasks__ETaskFlags) Flags )


className: TDummyType

description: TDummyType< void >

code: template<typename T> class TDummyType : public [CoroTask_Detail::FDummyType](API\Runtime\Core\Experimental\Coroutine\FDummyType)


className: TDummyType< void >::Launch

code: TDummyType< void > Launch &40; const TCHAR &42; DebugName, LowLevelTasks::ETaskPriority Priority, LowLevelTasks::EQueuePreference QueuePreference, LowLevelTasks::ETaskFlags Flags &41;


className: TDummyType< void >

code: template<> class TDummyType< void > : public [CoroTask_Detail::FDummyType](API\Runtime\Core\Experimental\Coroutine\FDummyType)


code: static void Free ( void * Pointer, SIZE_T Size )


code: static void * Malloc ( SIZE_T Size, uint32 Alignment )


className: SupportsAlignment

code: static constexpr bool SupportsAlignment = true;


className: UsesFMalloc

code: static constexpr bool UsesFMalloc = true;


className: FAlignedAllocatorInternal

code: struct FAlignedAllocatorInternal


className: Allocator

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


className: AllowOversizedBlocks

code: static constexpr bool AllowOversizedBlocks = true;


className: InlineBlockAllocation

code: static constexpr bool InlineBlockAllocation = false;


className: BlockSize

code: static constexpr uint32 BlockSize = 64 * 1024;


className: TagName

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


className: RequiresAccurateSize

code: static constexpr bool RequiresAccurateSize = true;


className: FDefaultBlockAllocationTag

code: struct FDefaultBlockAllocationTag


code: static constexpr bool SupportsAlignment = false;


description: Indicates whether memory is acquired from the same source as used byFMalloci.e. FMemory/FPlatformMemory::BaseAllocator(). It's needed so that ConcurrentLinearAllocator could correctly account for this memory in the memory stats and tracking systems. It is 'true' by default, which is suitable for most implementations. However, if you create a custom allocator that acquires memory in a different way e.g. directly from the OS usingFPlatformMemory::BinnedAllocFromOS, then you should set this variable to 'false'.


code: [FGraph](API\Runtime\Core\Experimental\Graph\FGraph) & operator= ( const [FGraph](API\Runtime\Core\Experimental\Graph\FGraph) & )


code: [FGraph](API\Runtime\Core\Experimental\Graph\FGraph) & operator= ( [FGraph](API\Runtime\Core\Experimental\Graph\FGraph) && )


description: Copy construction not implemented as buffers may be very large and expensive to copy.

code: FGraph ( const [FGraph](API\Runtime\Core\Experimental\Graph\FGraph) & )


code: FGraph ( [FGraph](API\Runtime\Core\Experimental\Graph\FGraph) && )


className: FGraph

description: Convenience structure for storing a graph in edge list form. EdgeLists[i] is a TConstArrayView of edges from Vertex i. Each element of EdgeList[i] is a an FVertex j such that (i, j) is an edge in the graph.

code: struct FGraph

Buffer

description: Singular buffer which each element of EdgeLists is a view into.

EdgeLists

type: TArray< TConstA...

description: Each member of EdgeLists is a slice of Buffer.


code: [FMappingManyToOne](API\Runtime\Core\Experimental\Graph\FMappingManyToOne) & operator= ( const [FMappingManyToOne](API\Runtime\Core\Experimental\Graph\FMappingManyToOne) & )


code: [FMappingManyToOne](API\Runtime\Core\Experimental\Graph\FMappingManyToOne) & operator= ( [FMappingManyToOne](API\Runtime\Core\Experimental\Graph\FMappingManyToOne) && )


code: FMappingManyToOne ( const [FMappingManyToOne](API\Runtime\Core\Experimental\Graph\FMappingManyToOne) & )


code: FMappingManyToOne ( [FMappingManyToOne](API\Runtime\Core\Experimental\Graph\FMappingManyToOne) && )


className: FMappingManyToOne

description: Represents a mapping between two graphs where each vertex in a source graph maps to exactly one vertex in a target graph. The mapping is not bidirectionally one-to-one. The length of Mapping is the number of vertices in the source graph and each value is a vertex in the target graph. e.g. a mapping from the vertices in a cyclic graph to the vertices in its condensation graph.

code: struct FMappingManyToOne

Mapping

type: TArray<FVertex...


code: [FMappingOneToMany](API\Runtime\Core\Experimental\Graph\FMappingOneToMany) & operator= ( const [FMappingOneToMany](API\Runtime\Core\Experimental\Graph\FMappingOneToMany) & )


code: [FMappingOneToMany](API\Runtime\Core\Experimental\Graph\FMappingOneToMany) & operator= ( [FMappingOneToMany](API\Runtime\Core\Experimental\Graph\FMappingOneToMany) && )


code: FMappingOneToMany ( const [FMappingOneToMany](API\Runtime\Core\Experimental\Graph\FMappingOneToMany) & )


code: FMappingOneToMany ( [FMappingOneToMany](API\Runtime\Core\Experimental\Graph\FMappingOneToMany) && )


className: FMappingOneToMany

description: Represents a mapping between two graphs where each vertex in a source graph maps to multiple vertices in a target graph. The length of Mapping is the number of vertices in the source graph and the contents of each mapping are vertices in the target graph. Buffer stores the contents of all array views in Mapping. e.g. a mapping between the vertices in a condensation graph and the original cyclic graph it was generated from.

code: struct FMappingOneToMany


code: namespace UE { namespace Graph { template<typename RangeType, typename GetKeyEdgesType> *It must return the TargetKeys that are pointed to from the directed edges from Key TargetKeys that are *not elements of UniqueKeys will be discarded TargetKeys equal to Key will also be discarded *RangeType must support ranged see [EConvertToGraphOptions](API\Runtime\Core\Experimental\Graph\UE__Graph__EConvertToGraphOption-) *return Output value that holds the graph See [FGraph](API\Runtime\Core\Experimental\Graph\FGraph)[for](API\Runtime\Core\Experimental\Graph\UE__Graph__for) a description of the format Vertex i in the graph *corresponds to UniqueKeys *[i] [FGraph](API\Runtime\Core\Experimental\Graph\FGraph) UE::Graph::ConvertToGraph ( const RangeType & UniqueKeys, GetKeyEdgesType GetKeyEdges, [EConvertToGraphOptions](API\Runtime\Core\Experimental\Graph\UE__Graph__EConvertToGraphOption-) Options ) } }


description: EConvertToGraphOptions.

code: namespace UE { namespace Graph { template<typename RangeType> [FGraph](API\Runtime\Core\Experimental\Graph\FGraph) UE::Graph::ConvertToSingleBufferGraph ( RangeType Graph, [EConvertToGraphOptions](API\Runtime\Core\Experimental\Graph\UE__Graph__EConvertToGraphOption-) Options ) } }


description: EConvertToGraphOptions.

code: namespace UE { namespace Graph { template<typename RangeType, typename ProjectionType> [FGraph](API\Runtime\Core\Experimental\Graph\FGraph) UE::Graph::ConvertToSingleBufferGraph ( RangeType && Graph, ProjectionType Proj, [EConvertToGraphOptions](API\Runtime\Core\Experimental\Graph\UE__Graph__EConvertToGraphOption-) Options ) } }


code: namespace UE { namespace Graph { enum EConvertToGraphOptions { None = 0, Shrink = 1 << 0, } } }


code: namespace UE { namespace Graph { *It must return the TargetKeys that are pointed to from the directed edges from Key TargetKeys that are *not elements of UniqueKeys will be discarded TargetKeys equal to Key will also be discarded *RangeType must support ranged UE::Graph::for ( begin() and end() ) } }


description: Convert an array of Keys and a function that returns the directed edges from each Key into the Normalized Graph Form. Normalized Graph Form is an implicit set of vertices identified as integers from 0 to N - 1, and an array of arrayviews of edges from each vertex. The Normalized Graph form has two structures: The buffer which contains the memory storage for the graph and the graph itself which is the array of arrayviews of edges. The length of the array in the graph defines the number of vertices.

code: namespace UE { namespace Graph { *const RangeType< KeyType > & UE::Graph::GetKeyEdges ( const KeyType & Key ) } }


code: namespace UE { namespace Graph { [EConvertToGraphOptions](API\Runtime\Core\Experimental\Graph\UE__Graph__EConvertToGraphOption-) & UE::Graph::operator|= ( [EConvertToGraphOptions](API\Runtime\Core\Experimental\Graph\UE__Graph__EConvertToGraphOption-) & Lhs, [EConvertToGraphOptions](API\Runtime\Core\Experimental\Graph\UE__Graph__EConvertToGraphOption-) Rhs ) } }


code: namespace UE { namespace Graph { [EConvertToGraphOptions](API\Runtime\Core\Experimental\Graph\UE__Graph__EConvertToGraphOption-) & UE::Graph::operator^= ( [EConvertToGraphOptions](API\Runtime\Core\Experimental\Graph\UE__Graph__EConvertToGraphOption-) & Lhs, [EConvertToGraphOptions](API\Runtime\Core\Experimental\Graph\UE__Graph__EConvertToGraphOption-) Rhs ) } }


code: namespace UE { namespace Graph { [EConvertToGraphOptions](API\Runtime\Core\Experimental\Graph\UE__Graph__EConvertToGraphOption-) & UE::Graph::operator&= ( [EConvertToGraphOptions](API\Runtime\Core\Experimental\Graph\UE__Graph__EConvertToGraphOption-) & Lhs, [EConvertToGraphOptions](API\Runtime\Core\Experimental\Graph\UE__Graph__EConvertToGraphOption-) Rhs ) } }


code: namespace UE { namespace Graph { constexpr [EConvertToGraphOptions](API\Runtime\Core\Experimental\Graph\UE__Graph__EConvertToGraphOption-) UE::Graph::operator| ( [EConvertToGraphOptions](API\Runtime\Core\Experimental\Graph\UE__Graph__EConvertToGraphOption-) Lhs, [EConvertToGraphOptions](API\Runtime\Core\Experimental\Graph\UE__Graph__EConvertToGraphOption-) Rhs ) } }


code: namespace UE { namespace Graph { constexpr [EConvertToGraphOptions](API\Runtime\Core\Experimental\Graph\UE__Graph__EConvertToGraphOption-) UE::Graph::operator& ( [EConvertToGraphOptions](API\Runtime\Core\Experimental\Graph\UE__Graph__EConvertToGraphOption-) Lhs, [EConvertToGraphOptions](API\Runtime\Core\Experimental\Graph\UE__Graph__EConvertToGraphOption-) Rhs ) } }


code: namespace UE { namespace Graph { constexpr [EConvertToGraphOptions](API\Runtime\Core\Experimental\Graph\UE__Graph__EConvertToGraphOption-) UE::Graph::operator^ ( [EConvertToGraphOptions](API\Runtime\Core\Experimental\Graph\UE__Graph__EConvertToGraphOption-) Lhs, [EConvertToGraphOptions](API\Runtime\Core\Experimental\Graph\UE__Graph__EConvertToGraphOption-) Rhs ) } }


code: namespace UE { namespace Graph { constexpr bool UE::Graph::operator! ( [EConvertToGraphOptions](API\Runtime\Core\Experimental\Graph\UE__Graph__EConvertToGraphOption-) E ) } }


code: namespace UE { namespace Graph { constexpr [EConvertToGraphOptions](API\Runtime\Core\Experimental\Graph\UE__Graph__EConvertToGraphOption-) UE::Graph::operator~ ( [EConvertToGraphOptions](API\Runtime\Core\Experimental\Graph\UE__Graph__EConvertToGraphOption-) E ) } }


code: static [TRefCountPtr](API\Runtime\Core\Templates\TRefCountPtr)< [IExecutionResource](API\Runtime\Core\Experimental\Misc\IExecutionResource) > Get()


className: FExecutionResourceContext

description: Per-thread stack-frame of execution resource currently held. Can be retrieved and passed around to other task until not needed anymore.

code: class FExecutionResourceContext


className: FExecutionResourceContextScope

description: Used to push an execution resource on the stack-frame that can be retrieved byFExecutionResourceContext::Get().

code: class FExecutionResourceContextScope


className: IExecutionResource

description: Simple ref-counted interface that represents a resource that is held or required for the execution of some task item.

code: class IExecutionResource : public [IRefCountedObject](API\Runtime\Core\Templates\IRefCountedObject)


code: FExecutionResourceContextScope ( [TRefCountPtr](API\Runtime\Core\Templates\TRefCountPtr)< [IExecutionResource](API\Runtime\Core\Experimental\Misc\IExecutionResource) > InExecutionResource )


code: static void * Malloc ( SIZE_T Size, uint32 Alignment )


code: static void Free ( void * Pointer, SIZE_T Size )


code: static constexpr bool SupportsAlignment = Allocator::SupportsAlignment;


code: static constexpr bool UsesFMalloc = Allocator::UsesFMalloc;


className: TBlockAllocationCache

code: template<uint32 BlockSize, typename Allocator> class TBlockAllocationCache


className: TBlockAllocationLockFreeCache

code: template<uint32 BlockSize, typename Allocator> class TBlockAllocationLockFreeCache


code: static SIZE_T GetAllocationSize ( void * Pointer )


code: template<typename T> static void * Malloc()


code: template<uint32 Alignment> static void * Malloc ( SIZE_T Size )


code: static void * Realloc ( void * Old, SIZE_T Size, uint32 Alignment )


className: SupportsFastPath

code: static constexpr bool SupportsFastPath = ((BlockAllocationTag::BlockSize <= (64 * 1024)) || 1 ) && FMath::IsPowerOfTwo(BlockAllocationTag::BlockSize) && ! 0 && !BlockAllocationTag::RequiresAccurateSize && BlockAllocationTag::Allocator::SupportsAlignment;


className: TConcurrentLinearAllocator

description: This concurrent fast linear Allocator can be used for temporary allocations that are usually produced and consumed on different threads and within the lifetime of a frame. Although the lifetime of any individual Allocation is not hard tied to a frame (tracking is done using the FBlockHeader::NumAllocations atomic variable) the Application will eventually run OOM if Allocations are not cleaned up in a timely manner. THere is a fastpath version of the allocator that skips Allocationheaders by aligning the BlockHeader with the Blocksize so that it easily can be found by AligingDOwn the Adress of the Allocation itself. The Allocator works by allocating a larger block in TLS which has a Header at the front which contains the Atomic and all allocations are than allocated from this block: | FBlockHeader(atomic counter etc.) | Alignment Waste | FAllocationHeader(size, optional) | Memory used for Allocation | Alignment Waste | FAllocationHeader(size, optional) | Memory used for Allocation | FreeSpace ...

code: template<typename BlockAllocationTag> class TConcurrentLinearAllocator


code: SizeType CalculateSlackGrow &40; SizeType NumElements, SizeType NumAllocatedElements, SIZE_T NumBytesPerElement &41; const


code: SizeType CalculateSlackReserve &40; SizeType NumElements, SIZE_T NumBytesPerElement &41; const


code: SizeType CalculateSlackShrink &40; SizeType NumElements, SizeType NumAllocatedElements, SIZE_T NumBytesPerElement &41; const


code: SIZE_T GetAllocatedSize &40; SizeType NumAllocatedElements, SIZE_T NumBytesPerElement &41; const


code: ElementType &42; GetAllocation&40;&41; const


description: Moves the state of another allocator into this one. Assumes that the allocator is currently empty, i.e. memory may be allocated but any existing elements have already been destructed (if necessary).

code: void MoveToEmpty &40; ForElementType & Other &41;


code: void ResizeAllocation &40; SizeType PreviousNumElements, SizeType NumElements, SIZE_T NumBytesPerElement &41;


code: ForElementType &40; const ForElementType & &41;


className: ForElementType

code: template<typename ElementType> class ForElementType


className: RequireRangeCheck

code: enum { RequireRangeCheck = true }


className: NeedsElementType

code: enum { NeedsElementType = true }


className: TConcurrentLinearArrayAllocator

code: template<typename BlockAllocationTag> class TConcurrentLinearArrayAllocator


code: template<typename T, typename... TArgs> T * Create ( TArgs &&... Args )


code: template<typename T, typename... TArgs> T * CreateArray ( SIZE_T Num, const TArgs &... Args )


code: void * Malloc ( SIZE_T Size, uint32 Alignment )


code: template<typename T> T * MallocAndMemset ( uint8 MemsetChar )


code: void * MallocAndMemset ( SIZE_T Size, uint32 Alignment, uint8 MemsetChar )


code: template<typename T> T * MallocAndMemsetArray ( SIZE_T Num, uint8 MemsetChar )


code: template<typename T> T * MallocArray ( SIZE_T Num )


className: ThisType

code: typedef [TConcurrentLinearBulkObjectAllocator](API\Runtime\Core\Experimental\TConcurrentLinearBulkObjectAlloc-)< BlockAllocationTag > ThisType


code: TConcurrentLinearBulkObjectAllocator()


className: TConcurrentLinearBulkObjectAllocator

description: The BulkObjectAllocator can be used to atomically destroy all allocated Objects, it will properly call every destructor before deleting the memory as well.

code: template<typename BlockAllocationTag> class TConcurrentLinearBulkObjectAllocator


code: ~TConcurrentLinearBulkObjectAllocator()


className: TConcurrentLinearObject::operator new

code: static void * operator new ( size_t Size )


code: static void * operator new ( size_t Size, void * Object )


code: static void operator delete[] ( void * Ptr )


code: static void operator delete ( void * Ptr )


code: static void * operator new ( size_t Size, std::align_val_t Align )


className: TConcurrentLinearObject::operator new[]

code: static void * operator new[] ( size_t Size, std::align_val_t Align )


code: static void * operator new[] ( size_t Size )


className: TConcurrentLinearObject

code: template<typename ObjectType, typename BlockAllocationTag> class TConcurrentLinearObject


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


code: static const [FCoreTexts](API\Runtime\Core\FCoreTexts) & Get()


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


description: Invalidates existing references. Do not useFCoreTextsafter calling.

code: static void TearDown()


description: Non-copyable.

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


code: FCoreTexts ( const [FText](API\Runtime\Core\Internationalization\FText) & InTrue, const [FText](API\Runtime\Core\Internationalization\FText) & InFalse, const [FText](API\Runtime\Core\Internationalization\FText) & InYes, const [FText](API\Runtime\Core\Internationalization\FText) & InNo, const [FText](API\Runtime\Core\Internationalization\FText) & InNone )


className: IModularFeature

description: All modular feature interfaces derive from this base interface

code: class IModularFeature


className: FOnModularFeatureRegistered

description: Event used to inform clients that a modular feature has been registered.

code: class FOnModularFeatureRegistered : public TBaseMulticastDelegate_TwoParams< void, const FName &, class IModularFeature * >


className: FOnModularFeatureUnregistered

description: Event used to inform clients that a modular feature has been unregistered.

code: class FOnModularFeatureUnregistered : public TBaseMulticastDelegate_TwoParams< void, const FName &, class IModularFeature * >


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


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


code: FScopedLockModularFeatureList &40; FScopedLockModularFeatureList && &41;


description: Non-copyable :

code: FScopedLockModularFeatureList &40; const FScopedLockModularFeatureList & &41;


className: FCoreTexts

code: struct FCoreTexts

False

type: constFText&


className: FScopedLockModularFeatureList

code: struct FScopedLockModularFeatureList


description:
Static: Access singleton instance
Reference to the singleton object

code: static [IModularFeatures](API\Runtime\Core\Features\IModularFeatures) & Get()


description:
Queries for a specific feature. If multiple implementations of the same feature were registered, this will return the first. Will assert or crash if the specified feature is not available! You should callIsModularFeatureAvailable()first!
The feature.

code: template<typename TModularFeature> TModularFeature & GetModularFeature ( const [FName](API\Runtime\Core\UObject\FName) Type )


description:
Queries for a specific modular feature. Returns NULL if the feature is not available. Does not assert. Usually you should just call GetModularFeature instead, after callingIsModularFeatureAvailable().
Pointer to the feature interface, or NULL if it's not available right now.

code: [IModularFeature](API\Runtime\Core\Features\IModularFeature) * GetModularFeatureImplementation ( const [FName](API\Runtime\Core\UObject\FName) Type, const int32 Index )


description:
Returns the number of registered implementations of the specified feature type.
Number of implementations of this feature.

code: int32 GetModularFeatureImplementationCount ( const [FName](API\Runtime\Core\UObject\FName) Type )


description:
Queries for one or more implementations of a single feature. If no feature of this type is registered, will return an empty array.
List of available implementations of this feature.

code: template<typename TModularFeature> [TArray](API\Runtime\Core\Containers\TArray)< TModularFeature * > GetModularFeatureImplementations ( const [FName](API\Runtime\Core\UObject\FName) Type )


description:
Checks to see if the specified feature is available
True if the feature is available right now and it is safe to callGetModularFeature()

code: bool IsModularFeatureAvailable ( const [FName](API\Runtime\Core\UObject\FName) Type )


description: Lock modular features for access from another thread

code: void LockModularFeatureList()


description: Registers a feature. Usually called by plugins to augment or replace existing modular features.

code: void RegisterModularFeature ( const [FName](API\Runtime\Core\UObject\FName) Type, class [IModularFeature](API\Runtime\Core\Features\IModularFeature) * ModularFeature )


description: Unlock modular features when finished accessing from another thread

code: void UnlockModularFeatureList()