className: RefCountType

code: typedef std::conditional_t< Mode==ESPMode::ThreadSafe, std::atomic< int32 >, int32 > RefCountType


description: Releases a shared reference to this counter

module: Core

code: void ReleaseSharedReference()


description: Releases a weak reference to this counter

code: void ReleaseWeakReference()


description: Non-copyable.

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


className: TReferenceControllerBase

code: template<ESPMode Mode> class TReferenceControllerBase

SharedReferenceCount

type: RefCountType

description: Number of shared references to this object.

WeakReferenceCount

description: Number of weak references to this object.


description: Destroys the object associated with this reference counter.

code: virtual void DestroyObject()


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


description: Non-copyable.

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


code: TReferenceControllerWithDeleter ( ObjectType * InObject, DeleterType && Deleter )


className: TReferenceControllerWithDeleter

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


className: TRemoveExtent

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

code: template<typename T> struct TRemoveExtent


className: TRemoveExtent< T[]>

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


className: TRemoveExtent< T[N]>

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


className: TRemovePointer

description: TRemovePointer< T * >

code: template<typename T> struct TRemovePointer


className: TRemovePointer< T * >

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


className: TRemoveReference

description: TRemoveReference< T & >TRemoveReference< T && >

code: template<typename T> struct TRemoveReference


className: TRemoveReference< T & >

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


className: TRemoveReference< T && >

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


className: TRetainedRef::operator T &

code: operator T &() const


description: Can't construct a non-const reference with a const reference and can't retain a rvalue reference.

code: TRetainedRef ( const T & InRef )


className: TRetainedRef

description: TRetainedRef< const T >

code: template<typename T> struct TRetainedRef


className: TRetainedRef< const T >::Get

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


className: TRetainedRef< const T >::operator const T &

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


className: TRetainedRef< const T >::TRetainedRef

code: TRetainedRef &40; T & InRef &41;


description: Can't retain a rvalue reference.

code: TRetainedRef &40; T && InRef &41;


code: TRetainedRef &40; const T & InRef &41;


code: TRetainedRef &40; const T && InRef &41;


code: TReversePredicate ( const PredicateType & InPredicate )


className: TRetainedRef< const T >

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


code: template<typename T> bool operator() ( T && A, T && B ) const


description: Two sorted arrays merging function.

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


className: TReversePredicate

description: Helper class to reverse a predicate. Performs Predicate(B, A)

code: template<typename PredicateType> class TReversePredicate


className: TRotationInPlaceMerge

description: TRotationPolicy Policy for array rotation algorithm.

code: template<class TRotationPolicy> class TRotationInPlaceMerge


className: TRValueToLValueReference

description: TRValueToLValueReference< T && >

code: template<typename T> struct TRValueToLValueReference


className: TRValueToLValueReference< T && >

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


code: TScopeCounter ( Type & ReferenceValue )


className: TScopeCounter

description: Commonly used to make sure a value is incremented, and then decremented anyway the function can terminate. Usage: TScopeCounterBeginProcessing(ProcessingCount); // increments ProcessingCount, and decrements it in the dtor

code: template<typename Type> struct TScopeCounter : private [FNoncopyable](API\Runtime\Core\Templates\FNoncopyable)


description:
Checks whether this callback has outstanding requests.
true if there are outstanding requests, false otherwise.

code: bool HasRequests() const


description: Request a callback.

code: void Request()


description: Unrequest a callback.

code: void Unrequest()


className: TScopedCallback

description: Helper object for batching callback requests and firing on destruction of the FScopedCallback object. CallbackType is a class implementing a static method called FireCallback, which does the work.

code: template<class CallbackType> class TScopedCallback


description:
Provides access to a shared reference to this object. Note that is only valid to call this after a shared reference (or shared pointer) to the object has already been created. Also note that it is illegal to call this in the object's destructor.
Returns this object as a shared pointer

code: [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< ObjectType, Mode > AsShared()


description: Fires a callback if outstanding requests exist.

code: ~TScopedCallback()


description:
Provides access to a shared reference to this object (const.) Note that is only valid to call this after a shared reference (or shared pointer) to the object has already been created. Also note that it is illegal to call this in the object's destructor.
Returns this object as a shared pointer (const)

code: [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< ObjectType const, Mode > AsShared() const


description:
Provides a weak reference to this object. Note that is only valid to call this after a shared reference (or shared pointer) to the object has already been created. Also note that it is illegal to call this in the object's destructor.
Returns this object as a shared pointer

code: [TWeakPtr](API\Runtime\Core\Templates\TWeakPtr)< ObjectType, Mode > AsWeak()


code: [TWeakPtr](API\Runtime\Core\Templates\TWeakPtr)< ObjectType const, Mode > AsWeak() const


description: Checks whether our referenced instance is valid (ie, whether it's safe to call AsShared). If this returns false, it means that your instance has either:

code: bool DoesSharedInstanceExist() const


description: Hidden stub assignment operator

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


description:
Provides access to a shared reference to an object, given the object's 'this' pointer. Uses the 'this' pointer to derive the object's actual type, then casts and returns an appropriately typed shared reference. Intentionally declared 'protected', as should only be called when the 'this' pointer can be passed.
Returns this object as a shared pointer

code: template<class OtherType> static [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< OtherType, Mode > SharedThis ( OtherType * ThisPtr )


description:
Provides access to a shared reference to an object, given the object's 'this' pointer. Uses the 'this' pointer to derive the object's actual type, then casts and returns an appropriately typed shared reference. Intentionally declared 'protected', as should only be called when the 'this' pointer can be passed.
Returns this object as a shared pointer (const)

code: template<class OtherType> static [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< OtherType const, Mode > SharedThis ( const OtherType * ThisPtr )


description: INTERNAL USE ONLY  Do not call this method. Freshens the internal weak pointer object using the supplied object pointer along with the authoritative shared reference to the object. Note that until this function is called, calls toAsShared()will result in an empty pointer.

code: template<class SharedPtrType, class OtherType> void UpdateWeakReferenceInternal ( [TSharedPtr](API\Runtime\Core\Templates\TSharedPtr)< SharedPtrType, Mode > const * InSharedPtr, OtherType * InObject ) const


code: template<class SharedRefType, class OtherType> void UpdateWeakReferenceInternal ( [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< SharedRefType, Mode > const * InSharedRef, OtherType * InObject ) const


description: Hidden stub constructor

code: TSharedFromThis()


description: Hidden stub copy constructor

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


description: Hidden destructor

code: ~TSharedFromThis()


className: TSharedFromThis

description: Derive your class fromTSharedFromThisto enable access to aTSharedRefdirectly from an object instance that's already been allocated. Use the optional Mode template argument for thread-safety.

code: template<class ObjectType, ESPMode Mode> class TSharedFromThis


className: ElementType

code: typedef ObjectType ElementType


description:
Returns the object referenced by this pointer, or nullptr if no object is reference
The object owned by this shared pointer, or nullptr

code: ObjectType * Get() const


description:
Returns the number of shared references to this object (including this reference.) IMPORTANT: Not necessarily fast! Should only be used for debugging purposes!
Number of shared references to the object (including this reference.)

code: int32 GetSharedReferenceCount() const


description:
Returns true if this is the only shared reference to this object. Note that there may be outstanding weak references left. IMPORTANT: Not necessarily fast! Should only be used for debugging purposes!
True if there is only one shared reference to the object, and this is it!

code: bool IsUnique() const


description:
Checks to see if this shared pointer is actually pointing to an object
True if the shared pointer is valid and can be dereferenced

code: const bool IsValid() const


className: Mode

code: static constexpr ESPMode Mode = InMode;


description:
Arrow operator returns a pointer to the object this shared pointer references
Returns a pointer to the object referenced by this shared pointer

code: ObjectType * operator->() const


className: TSharedPtr::operator bool

code: operator bool() const


description: Assignment to a nullptr pointer. The object currently referenced by this shared pointer will no longer be referenced and will be deleted if there are no other referencers.

code: [TSharedPtr](API\Runtime\Core\Templates\TSharedPtr) & operator= ( [SharedPointerInternals::FNullTag](API\Runtime\Core\Templates\FNullTag) * )


description: Assignment operator replaces this shared pointer with the specified shared pointer. The object currently referenced by this shared pointer will no longer be referenced and will be deleted if there are no other referencers.

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


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


code: template<typename OtherType, typename> [TSharedPtr](API\Runtime\Core\Templates\TSharedPtr) & operator= ( [SharedPointerInternals::TRawPtrProxy](API\Runtime\Core\Templates\TRawPtrProxy)< OtherType > const & InRawPtrProxy )


code: template<typename OtherType, typename DeleterType, typename> [TSharedPtr](API\Runtime\Core\Templates\TSharedPtr) & operator= ( [SharedPointerInternals::TRawPtrProxyWithDeleter](API\Runtime\Core\Templates\TRawPtrProxyWithDeleter)< OtherType, DeleterType > const & InRawPtrProxy )


code: template<typename OtherType, typename DeleterType, typename> [TSharedPtr](API\Runtime\Core\Templates\TSharedPtr) & operator= ( [SharedPointerInternals::TRawPtrProxyWithDeleter](API\Runtime\Core\Templates\TRawPtrProxyWithDeleter)< OtherType, DeleterType > && InRawPtrProxy )


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

code: [FMakeReferenceTo](API\Runtime\Core\Templates\FMakeReferenceTo)< ObjectType >::Type operator*() const


description: Resets this shared pointer, removing a reference to the object. If there are no other shared references to the object then it will be destroyed.

code: void Reset()


description:
Converts a shared pointer to a shared reference. The pointermustbe valid or an assertion will trigger.
Reference to the object

code: [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< ObjectType, Mode > ToSharedRef() const


code: [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< ObjectType, Mode > ToSharedRef()


description:
Converts a shared pointer to a weak ptr.
Weak pointer to the object

code: [TWeakPtr](API\Runtime\Core\Templates\TWeakPtr)< ObjectType, Mode > ToWeakPtr() const


description: Constructs an empty shared pointer

code: TSharedPtr ( [SharedPointerInternals::FNullTag](API\Runtime\Core\Templates\FNullTag) * )


description: NOTE: This constructor is private to force users to be explicit when converting a weak pointer to a shared pointer. Use the weak pointer's Pin() method instead!

code: template<typename OtherType, typename> TSharedPtr &40; TWeakPtr< OtherType, Mode > const & InWeakPtr &41;


code: template<typename OtherType, typename> TSharedPtr &40; TWeakPtr< OtherType, Mode > && InWeakPtr &41;


description: Constructs a shared pointer that owns the specified object. Note that passing nullptr here will still create a tracked reference to a nullptr pointer. (Consistent with std::shared_ptr)

code: template<typename OtherType, typename DeleterType, typename> TSharedPtr ( OtherType * InObject, DeleterType && InDeleter )


description: Special constructor used internally to statically cast one shared pointer type to another. You should never call this constructor directly. Instead, use the StaticCastSharedPtr() function. This constructor creates a shared pointer as a shared reference to an existing shared pointer after statically casting that pointer's object. This constructor is needed for static casts.

code: template<typename OtherType> TSharedPtr ( [TSharedPtr](API\Runtime\Core\Templates\TSharedPtr)< OtherType, Mode > const & InSharedPtr, [SharedPointerInternals::FStaticCastTag](API\Runtime\Core\Templates\FStaticCastTag) )


description: Special constructor used internally to cast a 'const' shared pointer a 'mutable' pointer. You should never call this constructor directly. Instead, use the ConstCastSharedPtr() function. This constructor creates a shared pointer as a shared reference to an existing shared pointer after const casting that pointer's object. This constructor is needed for const casts.

code: template<typename OtherType> TSharedPtr ( [TSharedPtr](API\Runtime\Core\Templates\TSharedPtr)< OtherType, Mode > const & InSharedPtr, [SharedPointerInternals::FConstCastTag](API\Runtime\Core\Templates\FConstCastTag) )


description: Aliasing constructor used to create a shared pointer which shares its reference count with another shared object, but pointing to a different object, typically a subobject.

code: template<typename OtherType> TSharedPtr ( [TSharedPtr](API\Runtime\Core\Templates\TSharedPtr)< OtherType, Mode > const & OtherSharedPtr, ObjectType * InObject )


code: template<typename OtherType> TSharedPtr ( [TSharedPtr](API\Runtime\Core\Templates\TSharedPtr)< OtherType, Mode > && OtherSharedPtr, ObjectType * InObject )


code: template<typename OtherType, typename> TSharedPtr ( OtherType * InObject )


code: template<typename OtherType> TSharedPtr ( [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< OtherType, Mode > const & OtherSharedRef, ObjectType * InObject )


description: Constructs a shared pointer using a proxy reference to a raw pointer. (See MakeShareable())

code: template<typename OtherType, typename> TSharedPtr ( [SharedPointerInternals::TRawPtrProxy](API\Runtime\Core\Templates\TRawPtrProxy)< OtherType > const & InRawPtrProxy )


code: template<typename OtherType, typename DeleterType, typename> TSharedPtr ( [SharedPointerInternals::TRawPtrProxyWithDeleter](API\Runtime\Core\Templates\TRawPtrProxyWithDeleter)< OtherType, DeleterType > const & InRawPtrProxy )


code: template<typename OtherType, typename DeleterType, typename> TSharedPtr ( [SharedPointerInternals::TRawPtrProxyWithDeleter](API\Runtime\Core\Templates\TRawPtrProxyWithDeleter)< OtherType, DeleterType > && InRawPtrProxy )


description: Constructs a shared pointer as a shared reference to an existing shared pointer's object. This constructor is needed so that we can implicitly upcast to base classes.

code: template<typename OtherType, typename> TSharedPtr ( [TSharedPtr](API\Runtime\Core\Templates\TSharedPtr)< OtherType, Mode > const & InSharedPtr )


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


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


description: Implicitly converts a shared reference to a shared pointer, adding a reference to the object. NOTE: We allow an implicit conversion fromTSharedReftoTSharedPtrbecause it's always a safe conversion.

code: template<typename OtherType, typename> TSharedPtr ( [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< OtherType, Mode > const & InSharedRef )


className: TSharedPtr

description: TSharedPtris a non-intrusive reference-counted authoritative object pointer. This shared pointer will be conditionally thread-safe when the optional Mode template argument is set to ThreadSafe.

code: template<class ObjectType, ESPMode InMode> class TSharedPtr


className: bHasIntrusiveUnsetOptionalState

description: Start - intrusiveTOptionalstate //.

code: static constexpr bool bHasIntrusiveUnsetOptionalState = true;


code: typedef ObjectType ElementType


description:
Returns a C++ reference to the object this shared reference is referencing
The object owned by this shared reference

code: ObjectType & Get() const


description:
Returns the number of shared references to this object (including this reference.) IMPORTANT: Not necessarily fast! Should only be used for debugging purposes!
Number of shared references to the object (including this reference.)

code: int32 GetSharedReferenceCount() const


description:
IMPORTANT: This has different behavior toGetSharedReferenceCount()== 1 in a multithreaded context. The expectation is that this will be used when a user wants exclusive write-access to an otherwise-immutable object. Care still needs to be taken when pinning TWeakPtrs to make new shared references.
True if there is only one shared reference to the object, and this is it!

code: bool IsUnique() const


code: static constexpr ESPMode Mode = InMode;


description:
Arrow operator returns a pointer to this shared reference's object
Returns a pointer to the object referenced by this shared reference

code: ObjectType * operator->() const


description: Assignment operator replaces this shared reference with the specified shared reference. The object currently referenced by this shared reference will no longer be referenced and will be deleted if there are no other referencers.

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


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


description: Assignment operator replaces this shared reference with the specified shared reference. The object currently referenced by this shared reference will no longer be referenced and will be deleted if there are no other referencers. Must not be nullptr.

code: template<typename OtherType, typename> [TSharedRef](API\Runtime\Core\Templates\TSharedRef) & operator= ( [SharedPointerInternals::TRawPtrProxy](API\Runtime\Core\Templates\TRawPtrProxy)< OtherType > const & InRawPtrProxy )


code: template<typename OtherType, typename DeleterType, typename> [TSharedRef](API\Runtime\Core\Templates\TSharedRef) & operator= ( [SharedPointerInternals::TRawPtrProxyWithDeleter](API\Runtime\Core\Templates\TRawPtrProxyWithDeleter)< OtherType, DeleterType > const & InRawPtrProxy )


code: template<typename OtherType, typename DeleterType, typename> [TSharedRef](API\Runtime\Core\Templates\TSharedRef) & operator= ( [SharedPointerInternals::TRawPtrProxyWithDeleter](API\Runtime\Core\Templates\TRawPtrProxyWithDeleter)< OtherType, DeleterType > && InRawPtrProxy )


code: void operator= ( FIntrusiveUnsetOptionalState )


code: bool operator== ( FIntrusiveUnsetOptionalState ) const


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

code: ObjectType & operator*() const


description:
Converts a shared reference to a shared pointer.
Shared pointer to the object

code: [TSharedPtr](API\Runtime\Core\Templates\TSharedPtr)< ObjectType, Mode > ToSharedPtr() const


description:
Converts a shared reference to a weak ptr.
Weak pointer to the object

code: [TWeakPtr](API\Runtime\Core\Templates\TWeakPtr)< ObjectType, Mode > ToWeakPtr() const


description: Used internally only. Please do not use!

code: TSharedRef()


description:
Converts a shared pointer to a shared reference. The pointermustbe valid or an assertion will trigger. NOTE: This explicit conversion constructor is intentionally private. Use 'ToSharedRef()' instead.
Reference to the object

code: template<typename OtherType, typename> TSharedRef &40; TSharedPtr< OtherType, Mode > const & InSharedPtr &41;


code: template<typename OtherType, typename> TSharedRef &40; TSharedPtr< OtherType, Mode > && InSharedPtr &41;


description: Constructs a shared reference that owns the specified object. Must not be nullptr.

code: template<typename OtherType, typename DeleterType, typename> TSharedRef ( OtherType * InObject, DeleterType && InDeleter )


description: Special constructor used internally to statically cast one shared reference type to another. You should never call this constructor directly. Instead, use the StaticCastSharedRef() function. This constructor creates a shared reference as a shared reference to an existing shared reference after statically casting that reference's object. This constructor is needed for static casts.

code: template<typename OtherType> TSharedRef ( [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< OtherType, Mode > const & InSharedRef, [SharedPointerInternals::FStaticCastTag](API\Runtime\Core\Templates\FStaticCastTag) )


description: Special constructor used internally to cast a 'const' shared reference a 'mutable' reference. You should never call this constructor directly. Instead, use the ConstCastSharedRef() function. This constructor creates a shared reference as a shared reference to an existing shared reference after const casting that reference's object. This constructor is needed for const casts.

code: template<typename OtherType> TSharedRef ( [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< OtherType, Mode > const & InSharedRef, [SharedPointerInternals::FConstCastTag](API\Runtime\Core\Templates\FConstCastTag) )


description: Aliasing constructor used to create a shared reference which shares its reference count with another shared object, but pointing to a different object, typically a subobject.

code: template<typename OtherType> TSharedRef ( [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< OtherType, Mode > const & OtherSharedRef, ObjectType * InObject )


code: TSharedRef &40; ObjectType &42; InObject, SharedPointerInternals::TReferenceControllerBase< Mode > &42; InSharedReferenceCount &41;


description: NOTE:TSharedRefhas no default constructor as it does not support empty references. You must initialize yourTSharedRefto a valid object at construction time. Constructs a shared reference that owns the specified object. Must not be nullptr.

code: template<typename OtherType, typename> TSharedRef ( OtherType * InObject )


description: Constructs a shared reference using a proxy reference to a raw pointer. (See MakeShareable()) Must not be nullptr.

code: template<typename OtherType, typename> TSharedRef ( [SharedPointerInternals::TRawPtrProxy](API\Runtime\Core\Templates\TRawPtrProxy)< OtherType > const & InRawPtrProxy )


code: template<typename OtherType, typename DeleterType, typename> TSharedRef ( [SharedPointerInternals::TRawPtrProxyWithDeleter](API\Runtime\Core\Templates\TRawPtrProxyWithDeleter)< OtherType, DeleterType > const & InRawPtrProxy )


code: template<typename OtherType, typename DeleterType, typename> TSharedRef ( [SharedPointerInternals::TRawPtrProxyWithDeleter](API\Runtime\Core\Templates\TRawPtrProxyWithDeleter)< OtherType, DeleterType > && InRawPtrProxy )


description: Constructs a shared reference as a reference to an existing shared reference's object. This constructor is needed so that we can implicitly upcast to base classes.

code: template<typename OtherType, typename> TSharedRef ( [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< OtherType, Mode > const & InSharedRef )


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


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


code: TSharedRef ( FIntrusiveUnsetOptionalState )


className: TSharedRef

description: Forward declarations.Bydefault, thread safety features are turned on. (Mode = ESPMode::ThreadSafe). If you need more concerned with performance of ref-counting, you should use ESPMode::NotThreadSafe.

code: template<class ObjectType, ESPMode InMode> class TSharedRef


className: TStorageOwnerType

code: template<typename FunctorType, bool bUnique, bool bOnHeap> struct TStorageOwnerType


className: TStorageOwnerTypeT

code: typedef typename [TStorageOwnerType](API\Runtime\Core\Templates\TStorageOwnerType)< FunctorType, bUnique, bOnHeap >::Type TStorageOwnerTypeT


className: Type

code: typedef TFunction_CopyableOwnedObject< typename TDecay< FunctorType >::Type, bOnHeap > Type


code: template<typename FunctorType, bool bOnHeap> struct TStorageOwnerType< FunctorType, false, bOnHeap >


code: typedef TFunction_UniqueOwnedObject< typename TDecay< FunctorType >::Type, bOnHeap > Type


className: TTupleArity

description: Traits class which calculates the number of elements in a tuple.

code: template<typename TupleType> struct TTupleArity : public [UE::Core::Private::Tuple::TCVTupleArity< const volatile TupleType >](API\Runtime\Core\Templates\TCVTupleArity)


code: template<typename IntegerSequence> struct TTransformTuple_Impl


code: template<typename FunctorType, bool bOnHeap> struct TStorageOwnerType< FunctorType, true, bOnHeap >


className: TTupleBase

code: template<typename Indices, typename... Types> struct TTupleBase


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


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


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


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


code: template<typename ArgType UE_REQUIRES> TTupleBaseElement ( [EForwardingConstructor](API\Runtime\Core\Templates\UE__Core__Private__Tuple__EForwa-), ArgType && Arg )


className: TTupleBaseElement

description: TTupleBaseElement< T, 0, 2 >

code: template<typename T, uint32 Index, uint32 TupleSize> struct TTupleBaseElement

Value

type: T


className: TTupleBaseElement< T, 0, 2 >::operator=

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


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


className: TTupleBaseElement< T, 0, 2 >::TTupleBaseElement


code: TTupleBaseElement &40; TTupleBaseElement && &41;


code: TTupleBaseElement &40; const TTupleBaseElement & &41;


code: template<typename ArgType UE_REQUIRES> TTupleBaseElement &40; EForwardingConstructor, ArgType && Arg &41;


className: TTupleBaseElement< T, 0, 2 >

code: template<typename T> struct TTupleBaseElement< T, 0, 2 >


code: template<typename TupleType> static decltype(auto) Get ( TupleType && Tuple )


code: template<typename DeducedType, typename TupleType> static decltype(auto) GetImpl ( const volatile [TTupleBaseElement](API\Runtime\Core\Templates\TTupleBaseElement)< DeducedType, [Index](API\Runtime\Chaos\Chaos\Index), TupleSize > &, TupleType && Tuple )


className: TTupleElementGetterByIndex

description: TTupleElementGetterByIndex< 0, 2 >

code: template<uint32 Index, uint32 TupleSize> struct TTupleElementGetterByIndex


className: TTupleElementGetterByIndex< 0, 2 >::Get

code: template<typename TupleType> static decltype(auto) Get &40; TupleType && Tuple &41;


className: TTupleElementGetterByIndex< 0, 2 >

code: template<> struct TTupleElementGetterByIndex< 0, 2 >


code: template<uint32 DeducedIndex, typename TupleType> static decltype(auto) GetImpl ( const volatile [TTupleBaseElement](API\Runtime\Core\Templates\TTupleBaseElement)< Type, DeducedIndex, TupleSize > &, TupleType && Tuple )


className: TTupleElementGetterByType

code: template<typename Type, uint32 TupleSize> struct TTupleElementGetterByType


code: const ElementType * GetTypedPtr() const


className: TTypeCompatibleBytes

description: An untyped array of data with compile-time alignment and size derived from another type.

code: template<typename ElementType> struct TTypeCompatibleBytes


className: TTypeTraits

description: Traits for types.

code: template<typename T> struct TTypeTraits : public [TTypeTraitsBase< T >](API\Runtime\Core\Templates\TTypeTraitsBase)


className: ConstInitType

code: typedef [TCallTraits](API\Runtime\Core\GenericPlatform\TCallTraits)< T >::ParamType ConstInitType


className: TTypeTraitsBase

description: Helper for array traits. Provides a common base to more easily refine a portion of the traits when specializing. Mainly used by MemoryOps.h which is used by the contiguous storage containers likeTArray.

code: template<typename T> struct TTypeTraitsBase


code: typedef TSignedIntType_T< sizeof(T)> TUnderlyingIntegerType_T


className: TUniqueFunction::operator bool

description: Tests if theTUniqueFunctionis callable.

code: FORCEINLINE operator bool() const


description: Copy/move assignment operator.

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


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


description: Removes any bound callable from theTFunction, restoring it to the default 'empty' state.

code: void Reset()


className: Super

code: typedef [UE::Core::Private::Function::TFunctionRefBase](API\Runtime\Core\Templates\TFunctionRefBase)< [UE::Core::Private::Function::TFunctionStorage](API\Runtime\Core\Templates\TFunctionStorage)< true >, FuncType > Super


description: Default constructor.

code: TUniqueFunction ( TYPE_OF_NULLPTR )


description: Constructor which binds aTFunctionto any function object.

code: template<typename FunctorType, typename> TUniqueFunction ( FunctorType && InFunc )


description: Constructor which takes ownership of aTFunction's functor.

code: TUniqueFunction ( [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< FuncType > && Other )


code: TUniqueFunction ( const [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< FuncType > & Other )


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


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


className: TUniqueFunction

description: voidFoo(TUniqueFunctionFunc);Foo(MovableFunc); // error -TUniqueFunctionis not copyableFoo(MoveTemp(MovableFunc)); // ok

code: template<typename FuncType> class TUniqueFunction : public [UE::Core::Private::Function::TFunctionRefBase< UE::Core::Private::Function::TFunctionStorage< true >, FuncType >](API\Runtime\Core\Templates\TFunctionRefBase)


description: Disallow copy-assignment.

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


description: Move-assignment is implemented as swapping the internal pointer.

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


code: template<typename Arg> [TUniqueObj](API\Runtime\Core\Templates\TUniqueObj) & operator= ( Arg && other )


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


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


description: AsTUniqueObj's internal pointer can never be null, we can't move that On the other hand we can call the move constructor of "T"

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


code: template<typename... Args> TUniqueObj ( Args &&... args )


className: TUniqueObj

description: This is essentially a reference version ofTUniquePtrUseful to force heap allocation of a value, e.g. in aTMapto give similar behaviour toTIndirectArray

code: template<typename T> class TUniqueObj


className: CounterBase

code: static constexpr int CounterBase = __COUNTER__;


description:
Returns a pointer to the owned object without relinquishing ownership.
A copy of the pointer to the object owned by theTUniquePtr, or nullptr if no object is being owned.

code: T * Get() const


description:
Returns a reference to the deleter subobject.
A reference to the deleter.

code: Deleter & GetDeleter()


code: const Deleter & GetDeleter() const


className: InterfaceType

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


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


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


className: InternalLinkType

description: InternalLinkType<COUNTER-CounterBase >

code: template<int Counter> struct InternalLinkType


description: Initialize(FTypeLayoutDesc& TypeDesc)

code: template<> struct InternalLinkType< COUNTER-CounterBase >


description:
Tests if theTUniquePtrcurrently owns an object.
true if theTUniquePtrcurrently owns an object, false otherwise.

code: bool IsValid() const


description:
Indirection operator
A pointer to the object owned by theTUniquePtr.

code: T * operator->() const


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


className: TUniquePtr::operator bool

description:
Operator bool
true if theTUniquePtrcurrently owns an object, false otherwise.

code: operator bool() const


description: Move assignment operator

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


description: Assignment operator for rvalues of other (usually derived) types

code: template<typename OtherT, typename OtherDeleter, typename> [TUniquePtr](API\Runtime\Core\Templates\TUniquePtr) & operator= ( [TUniquePtr](API\Runtime\Core\Templates\TUniquePtr)< OtherT, OtherDeleter > && Other )


description: Nullptr assignment operator

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


description:
Equality comparison operator
true if the two TUniquePtrs are logically substitutable for each other, false otherwise.

code: template<typename RhsT> bool operator== ( const [TUniquePtr](API\Runtime\Core\Templates\TUniquePtr)< RhsT > & Rhs ) const


description:
Equality comparison operator against nullptr.
true if theTUniquePtris null, false otherwise.

code: bool operator== ( TYPE_OF_NULLPTR ) const


description:
Inequality comparison operator
false if the two TUniquePtrs are logically substitutable for each other, true otherwise.

code: template<typename RhsT> bool operator!= ( const [TUniquePtr](API\Runtime\Core\Templates\TUniquePtr)< RhsT > & Rhs ) const


description:
Dereference operator
A reference to the object owned by theTUniquePtr.

code: T & operator*() const


description:
Relinquishes control of the owned object to the caller and nulls theTUniquePtr.
The pointer to the object that was owned by theTUniquePtr, or nullptr if no object was being owned.

code: T * Release()


description: Gives theTUniquePtra new object to own, destroying any previously-owned object.

code: void Reset ( T * InPtr )


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


description: Default constructor - initializes theTUniquePtrto null.

code: TUniquePtr()


description: Non-copyable.

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


description:
Inequality comparison operator against nullptr.
true if theTUniquePtris not null, false otherwise.

code: bool operator!= ( TYPE_OF_NULLPTR ) const


description: Pointer constructor - takes ownership of the pointed-to object

code: template<typename U, typename> TUniquePtr ( U * InPtr )


description: Nullptr constructor - initializes theTUniquePtrto null.

code: TUniquePtr ( TYPE_OF_NULLPTR )


description: Move constructor

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


description: Constructor from rvalues of other (usually derived) types

code: template<typename OtherT, typename OtherDeleter, typename> TUniquePtr ( [TUniquePtr](API\Runtime\Core\Templates\TUniquePtr)< OtherT, OtherDeleter > && Other )


code: template<typename U, typename> TUniquePtr ( U * InPtr, const Deleter & InDeleter )


code: template<typename U, typename> TUniquePtr ( U * InPtr, Deleter && InDeleter )


description: Destructor

code: ~TUniquePtr()


className: TUniquePtr

description: TUniquePtr< T[], Deleter >

code: template<typename T, typename Deleter> class TUniquePtr : private Deleter


className: TUniquePtr< T[], Deleter >::Get

description:
Returns a pointer to the owned array without relinquishing ownership.
A copy of the pointer to the array owned by theTUniquePtr, or nullptr if no array is being owned.


className: TUniquePtr< T[], Deleter >::GetDeleter

description:
Returns a reference to the deleter subobject.
A reference to the deleter.

code: Deleter & GetDeleter&40;&41;


code: const Deleter & GetDeleter&40;&41; const


className: TUniquePtr< T[], Deleter >::IsValid

description:
Tests if theTUniquePtrcurrently owns an array.
true if theTUniquePtrcurrently owns an array, false otherwise.

code: bool IsValid&40;&41; const


className: TUniquePtr< T[], Deleter >::operator bool

description:
Operator bool
true if theTUniquePtrcurrently owns an array, false otherwise.

code: operator bool&40;&41; const


className: TUniquePtr< T[], Deleter >::operator=

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


description: Move assignment operator

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


description: Assignment operator for rvalues of other (usually less qualified) types

code: template<typename OtherT, typename OtherDeleter, typename> TUniquePtr & operator&61; &40; TUniquePtr< OtherT, OtherDeleter > && Other &41;


description: Nullptr assignment operator

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


className: TUniquePtr< T[], Deleter >::operator==

code: template<typename RhsT> bool operator&61;&61; &40; const TUniquePtr< RhsT > & Rhs &41; const


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


className: TUniquePtr< T[], Deleter >::operator!=

code: template<typename RhsT> bool operator&33;&61; &40; const TUniquePtr< RhsT > & Rhs &41; const


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


className: TUniquePtr< T[], Deleter >::operator[]

description:
Indexing operator
A reference to the object at the specified index by theTUniquePtr.

code: T & operator&91;&93; &40; SIZE_T Index &41; const


className: TUniquePtr< T[], Deleter >::Release

description:
Relinquishes control of the owned array to the caller and nulls theTUniquePtr.
The pointer to the array that was owned by theTUniquePtr, or nullptr if no array was being owned.


className: TUniquePtr< T[], Deleter >::Reset

description: Gives theTUniquePtra new array to own, destroying any previously-owned array.

code: template<typename U, typename> void Reset &40; U &42; InPtr &41;


code: void Reset &40; TYPE_OF_NULLPTR InPtr &41;


className: TUniquePtr< T[], Deleter >::TUniquePtr


description: Non-copyable.

code: TUniquePtr &40; const TUniquePtr & &41;


description: Pointer constructor - takes ownership of the pointed-to array

code: template<typename U, typename> TUniquePtr &40; U &42; InPtr &41;


code: TUniquePtr &40; TYPE_OF_NULLPTR &41;


description: Move constructor

code: TUniquePtr &40; TUniquePtr && Other &41;


description: Constructor from rvalues of other (usually less qualified) types

code: template<typename OtherT, typename OtherDeleter, typename> TUniquePtr &40; TUniquePtr< OtherT, OtherDeleter > && Other &41;


code: template<typename U, typename> TUniquePtr &40; U &42; InPtr, Deleter && InDeleter &41;


code: template<typename U, typename> TUniquePtr &40; U &42; InPtr, const Deleter & InDeleter &41;


className: TUniquePtr< T[], Deleter >::~TUniquePtr

description: Destructor


className: TUniquePtr< T[], Deleter >

code: template<typename T, typename Deleter> class TUniquePtr< T[], Deleter > : private Deleter


className: TUseBitwiseSwap

code: template<typename T> struct TUseBitwiseSwap


className: Value

description: We don't use bitwise swapping for 'register' types because this will force them into memory and be slower.

code: enum { Value = !(std::is_enum_v<T> || std::is_pointer_v<T> || std::is_arithmetic_v<T>) }


code: TValueOrError_ErrorProxy ( ArgTypes &&... InArgs )


code: template<typename... ArgTypes> struct TValueOrError_ErrorProxy

Args

type: TTuple< ArgType...


code: TValueOrError_ValueProxy ( ArgTypes &&... InArgs )


code: template<typename... ArgTypes> struct TValueOrError_ValueProxy


className: TValueOrError< ValueType, void >::GetValue

description: Access the value. Asserts if this does not have a value.

code: ValueType & GetValue&40;&41;


code: const ValueType & GetValue&40;&41; const


code: ValueType GetValue&40;&41;


className: TValueOrError< ValueType, void >::HasError

description: Whether the error is set. An error does imply no value.

code: bool HasError&40;&41; const


className: TValueOrError< ValueType, void >::HasValue

description: Whether the value is set. A value does imply no error.

code: bool HasValue&40;&41; const


className: TValueOrError< ValueType, void >::StealValue

description: Steal the value. Asserts if this does not have a value. This causes the value to be unset.

code: ValueType StealValue&40;&41;


className: TValueOrError< ValueType, void >::TryGetValue

description: Access the value if it is set.

code: ValueType &42; TryGetValue&40;&41;


code: const ValueType &42; TryGetValue&40;&41; const


className: TValueOrError< ValueType, void >::TValueOrError

description: Construct the value from a proxy from MakeValue.

code: template<typename... ArgTypes> TValueOrError &40; TValueOrError_ValueProxy< ArgTypes... > && Proxy &41;


description: Construct the error from a proxy from MakeError.

code: TValueOrError &40; TValueOrError_ErrorProxy<> && Proxy &41;


code: template<typename... ArgTypes, uint32... ArgIndices> TValueOrError &40; TValueOrError_ValueProxy< ArgTypes... > && Proxy, TIntegerSequence< uint32, ArgIndices... > &41;


className: TValueOrError< ValueType, void >

code: template<typename ValueType> class TValueOrError< ValueType, void >


className: TValueOrError< void, ErrorType >::GetError

description: Access the error. Asserts if this does not have an error.

code: ErrorType & GetError&40;&41;


code: const ErrorType & GetError&40;&41; const


code: ErrorType GetError&40;&41;


className: TValueOrError< void, ErrorType >::HasError


className: TValueOrError< void, ErrorType >::HasValue


className: TValueOrError< void, ErrorType >::StealError

description: Steal the error. Asserts if this does not have an error. This causes the error to be unset.

code: ErrorType StealError&40;&41;


className: TValueOrError< void, ErrorType >::TryGetError

code: const ErrorType &42; TryGetError&40;&41; const


description: Access the error if it is set.

code: ErrorType &42; TryGetError&40;&41;


className: TValueOrError< void, ErrorType >::TValueOrError

code: TValueOrError &40; TValueOrError_ValueProxy<> && Proxy &41;


code: template<typename... ArgTypes> TValueOrError &40; TValueOrError_ErrorProxy< ArgTypes... > && Proxy &41;


code: template<typename... ArgTypes, uint32... ArgIndices> TValueOrError &40; TValueOrError_ErrorProxy< ArgTypes... > && Proxy, TIntegerSequence< uint32, ArgIndices... > &41;


className: TValueOrError< void, ErrorType >

code: template<typename ErrorType> class TValueOrError< void, ErrorType >


className: TValueOrError< void, void >::HasError

code: bool HasError&40;&41; const


className: TValueOrError< void, void >::HasValue

code: bool HasValue&40;&41; const


className: TValueOrError< void, void >::TValueOrError


className: TValueOrError< void, void >

code: template<> class TValueOrError< void, void >


code: template<typename IntegerSequence> struct TVisitTupleElements_Impl


className: TVoid

code: template<typename T> struct TVoid


className: ElementType

code: typedef ObjectType ElementType


description: Returns true if the object this weak pointer points to is the same as the specified object pointer.

code: bool HasSameObject ( const void * InOtherPtr ) const


description:
Checks to see if this weak pointer actually has a valid reference to an object
True if the weak pointer is valid and a pin operator would have succeeded

code: bool IsValid() const


className: Mode

code: static constexpr ESPMode Mode = InMode;


description: Assignment to a nullptr pointer. Clears this weak pointer's reference.

code: [TWeakPtr](API\Runtime\Core\Templates\TWeakPtr) & operator= ( [SharedPointerInternals::FNullTag](API\Runtime\Core\Templates\FNullTag) * )


description: Assignment operator adds a weak reference to the object referenced by the specified weak pointer

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


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


description: Assignment operator adds a weak reference to the object referenced by the specified weak pointer. This assignment operator is intended to allow derived-to-base conversions.

code: template<typename OtherType, typename> [TWeakPtr](API\Runtime\Core\Templates\TWeakPtr) & operator= ( [TWeakPtr](API\Runtime\Core\Templates\TWeakPtr)< OtherType, Mode > const & InWeakPtr )


description: Assignment operator sets this weak pointer from a shared reference

code: template<typename OtherType, typename> [TWeakPtr](API\Runtime\Core\Templates\TWeakPtr) & operator= ( [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< OtherType, Mode > const & InSharedRef )


code: template<typename OtherType, typename> [TWeakPtr](API\Runtime\Core\Templates\TWeakPtr) & operator= ( [TWeakPtr](API\Runtime\Core\Templates\TWeakPtr)< OtherType, Mode > && InWeakPtr )


description: Assignment operator sets this weak pointer from a shared pointer

code: template<typename OtherType, typename> [TWeakPtr](API\Runtime\Core\Templates\TWeakPtr) & operator= ( [TSharedPtr](API\Runtime\Core\Templates\TSharedPtr)< OtherType, Mode > const & InSharedPtr )


description:
Converts this weak pointer to a shared pointer that you can use to access the object (if it hasn't expired yet.) Remember, if there are no more shared references to the object, the returned shared pointer will not be valid. You should always check to make sure the returned pointer is valid before trying to dereference the shared pointer!
Shared pointer for this object (will only be valid if still referenced!)

code: [TSharedPtr](API\Runtime\Core\Templates\TSharedPtr)< ObjectType, Mode > Pin() const


description: Resets this weak pointer, removing a weak reference to the object. If there are no other shared or weak references to the object, then the tracking object will be destroyed.

code: void Reset()


code: [TSharedPtr](API\Runtime\Core\Templates\TSharedPtr)< ObjectType, Mode > Pin()


description: Constructs an emptyTWeakPtr

code: TWeakPtr ( [SharedPointerInternals::FNullTag](API\Runtime\Core\Templates\FNullTag) * )


description: Constructs a weak pointer from a shared reference

code: template<typename OtherType, typename> TWeakPtr ( [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< OtherType, Mode > const & InSharedRef )


description: Constructs a weak pointer from a shared pointer

code: template<typename OtherType, typename> TWeakPtr ( [TSharedPtr](API\Runtime\Core\Templates\TSharedPtr)< OtherType, Mode > const & InSharedPtr )


description: Constructs a weak pointer from a weak pointer of another type. This constructor is intended to allow derived-to-base conversions.

code: template<typename OtherType, typename> TWeakPtr ( [TWeakPtr](API\Runtime\Core\Templates\TWeakPtr)< OtherType, Mode > const & InWeakPtr )


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


code: template<typename OtherType, typename> TWeakPtr ( [TWeakPtr](API\Runtime\Core\Templates\TWeakPtr)< OtherType, Mode > && InWeakPtr )


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


description: Special constructor used internally to statically cast one weak pointer type to another. You should never call this constructor directly. Instead, use the StaticCastWeakPtr() function. This constructor creates a weak pointer as a weak reference to an existing weak pointer after statically casting that pointer's object. This constructor is needed for static casts.

code: template<typename OtherType> TWeakPtr ( [TWeakPtr](API\Runtime\Core\Templates\TWeakPtr)< OtherType, Mode > const & InWeakPtr, [SharedPointerInternals::FStaticCastTag](API\Runtime\Core\Templates\FStaticCastTag) )


description: Special constructor used internally to cast a 'const' weak pointer a 'mutable' pointer. You should never call this constructor directly. Instead, use the ConstCastWeakPtr() function. This constructor creates a weak pointer as a weak reference to an existing weak pointer after const casting that pointer's object. This constructor is needed for const casts.

code: template<typename OtherType> TWeakPtr ( [TWeakPtr](API\Runtime\Core\Templates\TWeakPtr)< OtherType, Mode > const & InWeakPtr, [SharedPointerInternals::FConstCastTag](API\Runtime\Core\Templates\FConstCastTag) )


className: TWeakPtr

description: TWeakPtris a non-intrusive reference-counted weak object pointer. This weak pointer will be conditionally thread-safe when the optional Mode template argument is set to ThreadSafe.

code: template<class ObjectType, ESPMode InMode> class TWeakPtr


code: namespace UE { namespace Core { namespace Private { namespace IsInvocable { template<typename CallableType, typename... ArgTypes> struct UE::Core::Private::IsInvocable::TIsInvocableImpl< typename TVoid< decltype(Invoke(DeclVal< CallableType >(), DeclVal< ArgTypes >() } } } }


code: namespace UE { namespace Core { namespace Private { template<typename FuncType, typename... ArgTypes> struct UE::Core::Private::TInvokeResult_Impl< decltype((void) Invoke(DeclVal< FuncType >() } } }


code: namespace UE { namespace Core { namespace Private { namespace Atomic { template<typename T, typename DiffType> T UE::Core::Private::Atomic::AddExchange ( volatile T * Element, DiffType Diff ) } } } }


code: namespace UE { namespace Core { namespace Private { namespace Atomic { template<typename T, typename DiffType> T * UE::Core::Private::Atomic::AddExchange ( T *volatile * Element, DiffType Diff ) } } } }


code: namespace UE { namespace Core { namespace Private { namespace Atomic { template<typename T> T UE::Core::Private::Atomic::AndExchange ( volatile T * Element, T AndValue ) } } } }


code: namespace UE { namespace Core { namespace Private { namespace Atomic { template<typename T> T UE::Core::Private::Atomic::CompareExchange ( volatile T * Element, T ExpectedValue, T NewValue ) } } } }


code: namespace UE { namespace Core { namespace Private { namespace Atomic { template<typename T> T UE::Core::Private::Atomic::DecrementExchange ( volatile T * Element ) } } } }


code: namespace UE { namespace Core { namespace Private { namespace Atomic { template<typename T> T * UE::Core::Private::Atomic::DecrementExchange ( T *volatile * Element ) } } } }


code: namespace UE { namespace Core { namespace Private { namespace Atomic { template<typename T> T * UE::Core::Private::Atomic::IncrementExchange ( T *volatile * Element ) } } } }


code: namespace UE { namespace Core { namespace Private { namespace Atomic { template<typename T> T UE::Core::Private::Atomic::Exchange ( volatile T * Element, T Value ) } } } }


code: namespace UE { namespace Core { namespace Private { namespace Atomic { template<typename T> T UE::Core::Private::Atomic::IncrementExchange ( volatile T * Element ) } } } }


code: namespace UE { namespace Core { namespace Private { namespace Atomic { template<typename T> T UE::Core::Private::Atomic::Load ( const volatile T * Element ) } } } }


code: namespace UE { namespace Core { namespace Private { namespace Atomic { template<typename T> T UE::Core::Private::Atomic::LoadRelaxed ( const volatile T * Element ) } } } }


code: namespace UE { namespace Core { namespace Private { namespace Atomic { template<typename T> T UE::Core::Private::Atomic::OrExchange ( volatile T * Element, T OrValue ) } } } }


code: namespace UE { namespace Core { namespace Private { namespace Atomic { template<typename T> void UE::Core::Private::Atomic::StoreRelaxed ( const volatile T * Element, T Value ) } } } }


code: namespace UE { namespace Core { namespace Private { namespace Atomic { template<typename T> void UE::Core::Private::Atomic::Store ( const volatile T * Element, T Value ) } } } }


code: namespace UE { namespace Core { namespace Private { namespace Atomic { template<typename T, typename DiffType> T UE::Core::Private::Atomic::SubExchange ( volatile T * Element, DiffType Diff ) } } } }


code: namespace UE { namespace Core { namespace Private { namespace Atomic { template<typename T, typename DiffType> T * UE::Core::Private::Atomic::SubExchange ( T *volatile * Element, DiffType Diff ) } } } }


className: UE::Core::Private::DeclVal< ArgTypes >

code: namespace UE { namespace Core { namespace Private { struct UE::Core::Private::DeclVal< ArgTypes >() } } }


code: namespace UE { namespace Core { namespace Private { namespace Atomic { template<typename T> T UE::Core::Private::Atomic::XorExchange ( volatile T * Element, T XorValue ) } } } }


code: namespace UE { namespace Core { namespace Private { template<typename OuterType, typename TargetType> auto UE::Core::Private::DereferenceIfNecessary ( TargetType && Target, const volatile OuterType * TargetPtr ) } } }


code: namespace UE { namespace Core { namespace Private { template<typename OuterType, typename TargetType> auto UE::Core::Private::DereferenceIfNecessary ( TargetType && Target, ... ) } } }


code: namespace UE { namespace Core { namespace Private { namespace Function { template<typename T> bool UE::Core::Private::Function::IsBound ( const T & Func ) } } } }


code: namespace UE { namespace Core { namespace Private { template<typename T> constexpr bool UE::Core::Private::IsDerivedFromSharedFromThisImpl ( const [TSharedFromThis](API\Runtime\Core\Templates\TSharedFromThis)< T > * ) } } }


code: namespace UE { namespace Core { namespace Private { constexpr bool UE::Core::Private::IsDerivedFromSharedFromThisImpl ( ... ) } } }


code: namespace UE { namespace Core { namespace Private { namespace IsInvocable { template<typename T> T && UE::Core::Private::IsInvocable::DeclVal() } } } }


description: Needed to work around an Android compiler bug - we need to construct aTSharedReffrom MakeShared without making MakeShared a friend in order to access the private constructor.

code: namespace UE { namespace Core { namespace Private { template<typename ObjectType, ESPMode Mode> [TSharedRef](API\Runtime\Core\Templates\TSharedRef)< ObjectType, Mode > UE::Core::Private::MakeSharedRef ( ObjectType * InObject, [SharedPointerInternals::TReferenceControllerBase](API\Runtime\Core\Templates\TReferenceControllerBase)< Mode > * InSharedReferenceCount ) } } }


code: namespace UE { namespace Core { namespace Private { template<typename Concept, typename... Ts> static char(& UE::Core::Private::ModelsResolve ( decltype &::< ... >Ts * ) } } }


code: namespace UE { namespace Core { namespace Private { template<typename Concept, typename... Ts> static char(& UE::Core::Private::ModelsResolve ( ... ) } } }


code: namespace UE { namespace Core { namespace Private { namespace PimplPtr { void UE::Core::Private::PimplPtr::CallDeleter ( void * Ptr ) } } } }


code: namespace UE { namespace Core { namespace Private { namespace PimplPtr { void * UE::Core::Private::PimplPtr::CallCopier ( void * Ptr ) } } } }


code: namespace UE { namespace Core { namespace Private { namespace PimplPtr { template<typename T> static void * UE::Core::Private::PimplPtr::CopyFunc ( void * A ) } } } }


code: namespace UE { namespace Core { namespace Private { namespace PimplPtr { template<typename T> void UE::Core::Private::PimplPtr::DeleterFunc ( void * Ptr ) } } } }


code: namespace UE { namespace Core { namespace Private { namespace Tuple { template<typename... Given, typename... Deduced> decltype([ConceptCheckingHelper](API\Runtime\Core\Templates\UE__Core__Private__Tuple__Concep-)((DeclVal< Given >()=DeclVal< Deduced && >(), 0)...)) UE::Core::Private::Tuple::AssignableConceptCheck ( Deduced && ... ) } } } }


code: namespace UE { namespace Core { namespace Private { namespace Tuple { template<typename LhsType, typename RhsType, uint32... Indices, decltype(ConceptCheckingHelper((DeclVal< LhsType & >().template Get< Indices >()=DeclVal< RhsType && >().template Get< Indices >(), 0)...))*> static void UE::Core::Private::Tuple::Assign ( LhsType & Lhs, RhsType && Rhs, [TIntegerSequence](API\Runtime\Core\Delegates\TIntegerSequence)< uint32, Indices... > ) } } } }


description: This only exists to have something to expand a parameter pack into, for concept checking.

code: namespace UE { namespace Core { namespace Private { namespace Tuple { template<typename... ArgTypes> void UE::Core::Private::Tuple::ConceptCheckingHelper ( ArgTypes && ... ) } } } }


code: namespace UE { namespace Core { namespace Private { namespace Tuple { template<typename... Given, typename... Deduced> std::enable_if_t< std::conjunction_v< std::is_constructible< Given, Deduced && >... > > UE::Core::Private::Tuple::ConstructibleConceptCheck ( Deduced && ... ) } } } }


code: namespace UE { namespace Core { namespace Private { namespace Tuple { enum EForwardingConstructor { ForwardingConstructor, } } } } }


code: namespace UE { namespace Core { namespace Private { namespace Tuple { template<typename... ElementTypes, typename... Types> [TTuple](API\Runtime\Core\Misc\TTuple)< ElementTypes... > UE::Core::Private::Tuple::MakeTupleImpl ( Types &&... Args ) } } } }


code: namespace UE { namespace Private { uint32 UE::Private::MurmurFinalize32 ( uint32 Hash ) } }


className: TElementType< const                                                                  T >

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


className: TElementType

code: template<typename T> struct TElementType : public [UE::Core::Private::ElementType::TImpl< T >](API\Runtime\Core\Traits\TImpl)


code: namespace UE { namespace Core { namespace Private { namespace Tuple { enum EOtherTupleConstructor { OtherTupleConstructor, } } } } }


className: TElementType< const                                                                  T[N]>

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


className: TElementType< const volatile T >

code: template<typename T> struct TElementType< const volatile T > : public [TElementType< T >](API\Runtime\Core\Traits\TElementType)


className: TElementType< const volatile T[N]>

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


className: TElementType<                                                                                T & >

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


className: TElementType<                                                                                T && >

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


className: TElementType<                                                                                T[N]>

description: Specialization for C arrays

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


className: TElementType<                                  volatile T >

code: template<typename T> struct TElementType< volatile T > : public [TElementType< T >](API\Runtime\Core\Traits\TElementType)


className: TElementType<                                  volatile T[N]>

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


className: TImpl

code: template<typename T, typename> struct TImpl


className: Value

code: static constexpr bool Value = UE::Core::Private::IsCharEncodingCompatibleWithImpl<std::remove_cv_t<SrcEncoding>, std::remove_cv_t<DestEncoding>>();


className: TIsCharEncodingCompatibleWith

description: This is not commutative. For example, ANSI is compatible with UTF-8, but UTF-8 is not compatible with ANSI.

code: template<typename SrcEncoding, typename DestEncoding> struct TIsCharEncodingCompatibleWith


code: static constexpr bool Value = UE::Core::Private::IsCharEncodingSimplyConvertibleToImpl<SrcEncoding, DestEncoding>();


className: TIsCharEncodingSimplyConvertibleTo

description: Trait which tests if code units of the source encoding are simply convertible (i.e. by assignment) to the destination encoding.

code: template<typename SrcEncoding, typename DestEncoding> struct TIsCharEncodingSimplyConvertibleTo


className: TIsCharType

code: template<typename T> struct TIsCharType


className: TIsCharType< ANSICHAR >

code: template<> struct TIsCharType< ANSICHAR >


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


className: TIsCharType< const volatile T >

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


className: TIsCharType< const                                                                  T >

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


className: TIsCharType< UCS2CHAR >

code: template<> struct TIsCharType< UCS2CHAR >


className: TIsCharType< UTF32CHAR >

code: template<> struct TIsCharType< UTF32CHAR >


className: TIsCharType< UTF8CHAR >

code: template<> struct TIsCharType< UTF8CHAR >


className: TIsCharType<                                  volatile T >

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


className: TIsCharType< WIDECHAR >

code: template<> struct TIsCharType< WIDECHAR >


className: TIsContiguousContainer< const                                                                  T >

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


className: TIsContiguousContainer< const                                                                  T[N]>

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


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


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


className: TIsContiguousContainer<                                                                                T & >

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


className: TIsContiguousContainer<                                                                                T && >

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


className: TIsContiguousContainer<                                                                                T[N]>

description: Specialization for C arrays (always contiguous)

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


className: TIsContiguousContainer<                                  volatile T[N]>

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


className: TIsContiguousContainer<                                  volatile T >

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


className: Value

code: static constexpr bool Value = UE::Core::Private::IsFixedWidthEncodingImpl<std::remove_cv_t<Encoding>>();


className: TIsFixedWidthCharEncoding

code: template<typename Encoding> struct TIsFixedWidthCharEncoding


className: TIsVoidTypeBase

code: template<typename T> struct TIsVoidTypeBase


className: TIsVoidTypeBase< void >

code: template<> struct TIsVoidTypeBase< void >


className: TIsVoidTypeBase< void const  >

code: template<> struct TIsVoidTypeBase< void const >


className: TIsVoidTypeBase< void const volatile >

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


className: TIsVoidTypeBase< void volatile >

code: template<> struct TIsVoidTypeBase< void volatile >


className: TMemberFunctionPtrOuter

code: template<typename T> struct TMemberFunctionPtrOuter


className: TSignedIntType

code: template<int NumBytes> struct TSignedIntType


className: TSignedIntType< 1 >

code: template<> struct TSignedIntType< 1 >


className: TSignedIntType< 2 >

code: template<> struct TSignedIntType< 2 >


className: TSignedIntType< 4 >

code: template<> struct TSignedIntType< 4 >


className: TSignedIntType< 8 >

code: template<> struct TSignedIntType< 8 >


className: TUnsignedIntType

code: template<int NumBytes> struct TUnsignedIntType


className: TUnsignedIntType< 1 >

code: template<> struct TUnsignedIntType< 1 >


className: TUnsignedIntType< 2 >

code: template<> struct TUnsignedIntType< 2 >


className: TUnsignedIntType< 4 >

code: template<> struct TUnsignedIntType< 4 >


className: TUnsignedIntType< 8 >

code: template<> struct TUnsignedIntType< 8 >


code: namespace UE { namespace Core { namespace Private { template<typename SrcEncoding, typename DestEncoding> constexpr bool UE::Core::Private::IsCharEncodingCompatibleWithImpl() } } }


code: namespace UE { namespace Core { namespace Private { template<typename SrcEncoding, typename DestEncoding> constexpr bool UE::Core::Private::IsCharEncodingSimplyConvertibleToImpl() } } }


description: Tests whether an encoding has fixed-width characters

code: namespace UE { namespace Core { namespace Private { template<typename Encoding> constexpr bool UE::Core::Private::IsFixedWidthEncodingImpl() } } }


code: namespace UE { namespace PixelFormat { bool UE::PixelFormat::HasCapabilities ( EPixelFormat InFormat, EPixelFormatCapabilities InCapabilities ) } }


className: FExtendedPlatformMemoryStats

description: Struct for more detailed stats that are slower to gather. Useful when using ForkAndWait().

code: struct FExtendedPlatformMemoryStats

description: Private memory used

description: Shared memory used


className: FLinuxPlatformMath

description: IWYU pragma: begin_exports Linux implementation of the Math OS functions

code: struct FLinuxPlatformMath : public [TUnrealPlatformMathSSE4Base< FClangPlatformMath >](API\Runtime\Core\Math\TUnrealPlatformMathSSE4Base)


description: Returns raw file handle.

code: int GetHandle() const


description: Returns the raw file handle of the other endpoint of PipeDesc

code: int GetPairHandle() const


description: Reads until EOF.


description: Reads until EOF.

code: bool ReadToArray ( [TArray](API\Runtime\Core\Containers\TArray)< uint8 > & Output )


className: FPipeHandle

description: Wrapper around Unix file descriptors

code: struct FPipeHandle

PairDesc

type: int


className: FPlatformMemoryStats

description: Unix implementation of theFGenericPlatformMemoryStats.

code: struct FPlatformMemoryStats : public [FGenericPlatformMemoryStats](API\Runtime\Core\GenericPlatform\FGenericPlatformMemoryStats)


description: Accessors.

code: pid_t Get() const


description: The below is not part ofFProcHandleAPI and is specific to Unix implementation

code: [FProcState](API\Runtime\Core\Unix\FProcState) * GetProcessInfo() const


description: Checks the validity of handle

code: bool IsValid() const


description: Resets the handle to invalid

code: void Reset()


code: FProcHandle ( [FProcState](API\Runtime\Core\Unix\FProcState) * InHandle )


className: FProcHandle

description: FProcHandlecan be copied (and thus passed by value).

code: struct FProcHandle

OpenedPid

description: Pid of external process opened with OpenProcess() call.

ProcInfo

type: FProcState*...

description: Child proc state set from CreateProc() call


description: Getter for process id

code: pid_t GetProcessId() const


description:
Returns child's return code (only valid to call if not running)
return whether we have the return code (we don't if it crashed)

code: bool GetReturnCode ( int32 * ReturnCodePtr )


description:
Returns whether this process is running.
true if running

code: bool IsRunning()


description: Assignment operator - should not be publicly accessible

code: [FProcState](API\Runtime\Core\Unix\FProcState) & operator= ( const [FProcState](API\Runtime\Core\Unix\FProcState) & Other )


description: Waits for the process to end. Has a side effect (stores child's return code).

code: void Wait()


description: Default constructor.

code: FProcState()


description: Copy constructor - should not be publicly accessible

code: FProcState ( const [FProcState](API\Runtime\Core\Unix\FProcState) & Other )


description: Initialization constructor.

code: FProcState ( pid_t InProcessId, bool bInFireAndForget )


description: Destructor.

code: ~FProcState()


className: FProcState

description: Wrapper around Unix pid_t. Should not be copyable as changes in the process state won't be properly propagated to all copies.

code: struct FProcState

bFireAndForget

type: bool

description: Whether this child is fire-and-forget

bHasBeenWaitedFor

description: Whether the process's return code has been collected

bIsRunning

description: Whether the process has finished or not (cached)

ProcessId

description: Process id

ReturnCode

description: Return code of the process (if negative, means that process did not finish gracefully but was killed/crashed


code: static void * AllocCrashHandlerStack()


code: static void FreeCrashHandlerStack ( void * StackBuffer )


className: MainThreadSignalHandlerStack

description: Separate stack for the signal handler (so possible stack overflows don't go unnoticed), for the main thread specifically.

code: static void * MainThreadSignalHandlerStack = nullptr;


description: Changes the thread priority of the currently running thread

code: virtual void SetThreadPriority ( EThreadPriority NewPriority )


code: virtual void SetThreadPriority ( pthread_t InThread, EThreadPriority NewPriority )


description:
This includes guard page at the end of the stack to make running out of stack more obvious. Should be run in the context of the thread.
true if setting the alt stack succeeded. Inability to set guard page will not affect success of the operation.

code: static bool SetupSignalHandlerStack ( void * StackBuffer, const size_t StackBufferSize, void ** OutStackGuardPageAddress )


description: On Unix, this translates to ranges of setpriority(). Note that not all range may be available

code: virtual int32 TranslateThreadPriority ( EThreadPriority Priority )


className: FRunnableThreadUnix

description: Unix implementation of the Process OS functions

code: class FRunnableThreadUnix : public FRunnableThreadPThread


description: Populates crash context stack trace and a few related fields for another thread

code: void CaptureThreadStackTrace ( uint32_t ThreadId )


description: Populates crash context stack trace and a few related fields for the calling thread

code: void CaptureStackTrace ( void * ErrorProgramCounter )


description:
Generates a new crash report containing information needed for the crash reporter and launches it; may not return.
If the crash type is not continuable, the function will not return


className: FakeSiginfoForDiagnostics

description: Fake siginfo used when handling ensure(), etc

code: static __thread siginfo_t FakeSiginfoForDiagnostics;


description: Write all the data mined from the minidump to a text file

code: void GenerateReport ( const [FString](API\Runtime\Core\Containers\FString) & DiagnosticsPath ) const


description: Gets the portable callstack to a specified stack and puts it into OutCallStack

code: virtual void GetPortableCallStack ( const uint64 * StackFrames, int32 NumStackFrames, [TArray](API\Runtime\Core\Containers\TArray)< [FCrashStackFrame](API\Runtime\Core\GenericPlatform\FCrashStackFrame) > & OutCallStack ) const


description: Inits the crash context from some diagnostic handler (ensure, stall, etc...)

code: void InitFromDiagnostics ( const void * InAddress )


description: Serializes platform specific properties to the buffer.

code: virtual void AddPlatformSpecificProperties() const


description: Inits the crash context from data provided by a signal handler.

code: void InitFromSignal ( int32 InSignal, siginfo_t * InInfo, void * InContext )


description: Sets the FirstCrashHandlerFrame only if it has not been set before

code: void SetFirstCrashHandlerFrame ( uint64 * ProgramCounter )


description: Sets whether this crash represents a non-crash event like an ensure

code: void SetType ( ECrashContextType InType )


code: FUnixCrashContext ( ECrashContextType InType, const TCHAR * InErrorMessage )


className: FUnixCrashContext

code: struct FUnixCrashContext : public [FGenericCrashContext](API\Runtime\Core\GenericPlatform\FGenericCrashContext)

BacktraceSymbols

type: char **

description: Symbols received via backtrace_symbols(), if any (note that we will need to clean it up)

bCapturedBacktrace

description: Whether backtrace was already captured

Context

type: ucontext_t *...

description: Thread context

ErrorFrame

type: void *

description: The PC of where the error being reported occurred.

FirstCrashHandlerFrame

type: uint64 *

description: The PC of the first function used when handling a crash.

Info

type: siginfo_t *

description: Additional signal info

MinidumpCallstackInfo

description: Memory reserved for minidump-style callstack info

Signal

description: Signal number

SignalDescription

description: Memory reserved for "exception" (signal) info


description: Error handling function that is being called from within the system wide global error handler, e.g. using structured exception handling on the PC.

code: virtual void HandleError()


description: Callback to allowFUnixApplicationErrorOutputDeviceto restore the UI.

code: virtual void HandleErrorRestoreUI()


description: Serializes the passed in data unless the current event is suppressed.

code: virtual void Serialize ( const TCHAR * Msg, [ELogVerbosity::Type](API\Runtime\Core\Logging\ELogVerbosity__Type) Verbosity, const class [FName](API\Runtime\Core\UObject\FName) & Category )


className: FUnixErrorOutputDevice

code: class FUnixErrorOutputDevice : public [FOutputDeviceError](API\Runtime\Core\Misc\FOutputDeviceError)


description: Constructor, initializing member variables

code: FUnixErrorOutputDevice()


code: static [FOutputDevice](API\Runtime\Core\Misc\FOutputDevice) * GetEventLog()


code: static [FOutputDeviceError](API\Runtime\Core\Misc\FOutputDeviceError) * GetError()


className: FUnixOutputDevices

code: struct FUnixOutputDevices : public [FGenericPlatformOutputDevices](API\Runtime\Core\GenericPlatform\FGenericPlatformOutputDevices)


description:
Copy a file. This will fail if the destination file already exists.
true if the file was copied sucessfully.

code: virtual bool CopyFile ( const TCHAR * To, const TCHAR * From, EPlatformFileRead ReadFlags, EPlatformFileWrite WriteFlags )


code: bool CreateDirectoriesFromPath ( const TCHAR * Path )


description: Create a directory and return true if the directory was created or already existed.

code: virtual bool CreateDirectory ( const TCHAR * Directory )


description: Delete a file and return true if the file exists. Will not delete read only files.

code: virtual bool DeleteFile ( const TCHAR * Filename )


description: Delete a directory and return true if the directory was deleted or otherwise does not exist.

code: virtual bool DeleteDirectory ( const TCHAR * Directory )


description: Return true if the directory exists.

code: virtual bool DirectoryExists ( const TCHAR * Directory )


description: Return the size of the file, or -1 if it doesn't exist.

code: virtual int64 FileSize ( const TCHAR * Filename )


description: Return true if the file exists.

code: virtual bool FileExists ( const TCHAR * Filename )


description: Return the stat data for the given file or directory. Check theFFileStatData::bIsValidmember before using the returned data

code: virtual [FFileStatData](API\Runtime\Core\GenericPlatform\FFileStatData) GetStatData ( const TCHAR * FilenameOrDirectory )


description: Return the last access time of a file. ReturnsFDateTime::MinValue()on failure

code: virtual [FDateTime](API\Runtime\Core\Misc\FDateTime) GetAccessTimeStamp ( const TCHAR * Filename )


description: Return true if the file is read only.

code: virtual bool IsReadOnly ( const TCHAR * Filename )


description: Return the modification time of a file. ReturnsFDateTime::MinValue()on failure

code: virtual [FDateTime](API\Runtime\Core\Misc\FDateTime) GetTimeStamp ( const TCHAR * Filename )


description: Return true if the file is a symbolic link

code: virtual ESymlinkResult IsSymlink ( const TCHAR * Filename )


code: bool IterateDirectoryCommon ( const TCHAR * Directory, const [TFunctionRef](API\Runtime\Core\GenericPlatform\TFunctionRef)< bool(struct dirent *)> & Visitor )


description:
Call the Visit function of the visitor once for each file or directory in a single directory. This function does not explore subdirectories.
false if the directory did not exist or if the visitor returned false.

code: virtual bool IterateDirectory ( const TCHAR * Directory, [FDirectoryVisitor](API\Runtime\Core\GenericPlatform\IPlatformFile\FDirectoryVisitor) & Visitor )


code: virtual bool IterateDirectoryStat ( const TCHAR * Directory, [FDirectoryStatVisitor](API\Runtime\Core\GenericPlatform\IPlatformFile\FDirectoryStatVisitor) & Visitor )


description: Attempt to move a file. Return true if successful. Will not overwrite existing files.

code: virtual bool MoveFile ( const TCHAR * To, const TCHAR * From )


code: virtual [FString](API\Runtime\Core\Containers\FString) NormalizeDirectory ( const TCHAR * Directory, bool bIsForWriting )


description: Unix File I/O implementation

code: virtual [FString](API\Runtime\Core\Containers\FString) NormalizeFilename ( const TCHAR * Filename, bool bIsForWriting )


description:
Open a file for async reading. This call does hit the disk; it is synchronous open.
Close the file by delete'ing the handle. A non-null return value does mean the file exists. Null can be returned for many reasons even if the file exists. Perhaps this platform does not support mapped files, or this file is compressed in a pak file. Generally you attempt to open mapped, and if that fails, then use other file operations instead.

code: virtual [IMappedFileHandle](API\Runtime\Core\Async\IMappedFileHandle) * OpenMapped ( const TCHAR * Filename )


description:
Attempt to open a file for reading.
If successful will return a non-nullptr pointer. Close the file by delete'ing the handle.

code: virtual [IFileHandle](API\Runtime\Core\GenericPlatform\IFileHandle) * OpenRead ( const TCHAR * Filename, bool bAllowWrite )


description: Attempt to open a file for writing. If successful will return a non-nullptr pointer. Close the file by delete'ing the handle.

code: virtual [IFileHandle](API\Runtime\Core\GenericPlatform\IFileHandle) * OpenWrite ( const TCHAR * Filename, bool bAppend, bool bAllowRead )


description: Attempt to change the read only status of a file. Return true if successful.

code: virtual bool SetReadOnly ( const TCHAR * Filename, bool bNewReadOnlyValue )


description: Sets the modification time of a file

code: virtual void SetTimeStamp ( const TCHAR * Filename, const [FDateTime](API\Runtime\Core\Misc\FDateTime) DateTime )


className: FUnixPlatformFile

description: Unix File I/O implementation

code: class FUnixPlatformFile : public [IPhysicalPlatformFile](API\Runtime\Core\GenericPlatform\IPhysicalPlatformFile)

bLoggingError

description: We're logging an error message.


code: static void * BinnedAllocFromOS ( SIZE_T Size )


code: static void BinnedFreeToOS ( void * Ptr, SIZE_T Size )


code: static FPlatformVirtualMemoryBlock AllocateVirtual &40; size_t Size, size_t InAlignment &41;


code: void Commit &40; size_t InOffset, size_t InSize &41;


code: static [FMalloc](API\Runtime\Core\HAL\FMalloc) * BaseAllocator()


code: void CommitByPtr &40; void &42; InPtr, size_t InSize &41;


code: void Decommit &40; size_t InOffset, size_t InSize &41;


code: void DecommitByPtr &40; void &42; InPtr, size_t InSize &41;


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


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


code: FPlatformVirtualMemoryBlock &40; void &42; InPtr, uint32 InVMSizeDivVirtualSizeAlignment &41;


className: FPlatformVirtualMemoryBlock

code: class FPlatformVirtualMemoryBlock : public FBasicVirtualMemoryBlock


description: Returns file descriptor of a shared memory object

code: int GetFileDescriptor&40;&41; const


description: Returns true if we need to unlink this region on destruction (no other process will be able to access it)

code: bool NeedsToUnlinkRegion&40;&41; const


code: FUnixSharedMemoryRegion &40; const FString & InName, uint32 InAccessMode, void &42; InAddress, SIZE_T InSize, int InFd, bool bInCreatedThisRegion &41;


className: FUnixSharedMemoryRegion

description: Unix representation of a shared memory region

code: struct FUnixSharedMemoryRegion : public FSharedMemoryRegion

bCreatedThisRegion

description: Whether we created this region

Fd

description: File descriptor of a shared region


code: static const FPlatformMemoryConstants & GetConstants()


description: LLM uses these low level functions (LLMAlloc and LLMFree) to allocate memory. It grabs the function pointers by callingFPlatformMemory::GetLLMAllocFunctions. If these functions are not implemented GetLLMAllocFunctions should return false and LLM will be disabled.

code: static bool GetLLMAllocFunctions ( void *(*&)(size_t) OutAllocFunction, void(*&)(void *, size_t) OutFreeFunction, int32 & OutAlignment )


code: static [FSharedMemoryRegion](API\Runtime\Core\GenericPlatform\FGenericPlatformMemory\FSharedMemoryRegion) * MapNamedSharedMemoryRegion ( const [FString](API\Runtime\Core\Containers\FString) & InName, bool bCreate, uint32 AccessMode, SIZE_T Size )


code: static void OnOutOfMemory ( uint64 Size, uint32 Alignment )


code: static bool PageProtect ( void *const Ptr, const SIZE_T Size, const bool bCanRead, const bool bCanWrite )


className: FUnixPlatformMemory

description: Unix implementation of the memory OS functions

code: struct FUnixPlatformMemory : public [FGenericPlatformMemory](API\Runtime\Core\GenericPlatform\FGenericPlatformMemory)


code: static bool UnmapNamedSharedMemoryRegion ( [FSharedMemoryRegion](API\Runtime\Core\GenericPlatform\FGenericPlatformMemory\FSharedMemoryRegion) * MemoryRegion )


code: static void CreateGuid ( [FGuid](API\Runtime\Core\Misc\FGuid) & Result )


code: static bool GetBlockingIOStats ( [FProcessIOStats](API\Runtime\Core\GenericPlatform\FProcessIOStats) & OutStats, EInputOutputFlags Flags )


code: static bool GetContextSwitchStats ( [FContextSwitchStats](API\Runtime\Core\GenericPlatform\FContextSwitchStats) & OutStats, EContextSwitchFlags Flags )


description:
Uses cpuid instruction to get the vendor string
CPU info bitfield     Bits 0-3    Stepping ID
    Bits 4-7    Model
    Bits 8-11   Family
    Bits 12-13  Processor type (Intel) / Reserved (AMD)
    Bits 14-15  Reserved
    Bits 16-19  Extended model
    Bits 20-27  Extended family
    Bits 28-31  Reserved

code: static uint32 GetCPUInfo()


code: static bool GetDiskTotalAndFreeSpace ( const [FString](API\Runtime\Core\Containers\FString) & InPath, uint64 & TotalNumberOfBytes, uint64 & NumberOfFreeBytes )


code: static [FString](API\Runtime\Core\Containers\FString) GetEnvironmentVariable ( const TCHAR * VariableName )


description: Deprecated* void FPlatformMisc::GetEnvironmentVariable(Name, Result, Length) is deprecated. UseFStringFPlatformMisc::GetEnvironmentVariable(Name) instead.

code: static void GetEnvironmentVariable ( const TCHAR * VariableName, TCHAR * Result, int32 ResultLength )


code: static [TArray](API\Runtime\Core\Containers\TArray)< uint8 > GetMacAddress()


description:
Determines the shader format for the platform
Returns the shader format to be used by that platform

code: static const TCHAR * GetNullRHIShaderFormat()


code: static void GetOSVersions ( [FString](API\Runtime\Core\Containers\FString) & out_OSVersionLabel, [FString](API\Runtime\Core\Containers\FString) & out_OSSubVersionLabel )


code: static bool GetPageFaultStats ( [FPageFaultStats](API\Runtime\Core\GenericPlatform\FPageFaultStats) & OutStats, EPageFaultFlags Flags )


code: static const TCHAR * GetPathVarDelimiter()


code: static [IPlatformChunkInstall](API\Runtime\Core\GenericPlatform\IPlatformChunkInstall) * GetPlatformChunkInstall()


code: static const TCHAR * GetSystemErrorMessage ( TCHAR * OutBuffer, int32 BufferCount, int32 Error )


description: Returns whether the program has been started remotely (e.g. over SSH)

code: static bool HasBeenStartedRemotely()


code: static bool HasNonoptionalCPUFeatures()


description:
Determines if return code has been overriden and returns it.
true if the error code has been overriden, false if not

code: static bool HasOverriddenReturnCode ( uint8 * OverriddenReturnCodeToUsePtr )


code: static void LowLevelOutputDebugString ( const TCHAR * Message )


code: static [EAppReturnType::Type](API\Runtime\Core\GenericPlatform\EAppReturnType__Type) MessageBoxExt ( [EAppMsgType::Type](API\Runtime\Core\GenericPlatform\EAppMsgType__Type) MsgType, const TCHAR * Text, const TCHAR * Caption )


code: static void NormalizePath ( FStringBuilderBase & InPath )


code: static void NormalizePath ( [FString](API\Runtime\Core\Containers\FString) & InPath )


code: static void RequestExit ( bool Force, const TCHAR * CallSite )


code: static void RequestExitWithStatus ( bool Force, uint8 ReturnCode, const TCHAR * CallSite )


code: static void SetCrashHandler ( void(*)(const [FGenericCrashContext](API\Runtime\Core\GenericPlatform\FGenericCrashContext) &[Context](API\Plugins\StateTreeModule\EStateTreeBindableStructSource)) CrashHandler )


code: static void SetEnvironmentVar ( const TCHAR * VariableName, const TCHAR * Value )


code: static bool SetStoredValues ( const [FString](API\Runtime\Core\Containers\FString) & InStoreId, const [FString](API\Runtime\Core\Containers\FString) & InSectionName, const [TMap](API\Runtime\Core\Containers\TMap)< [FString](API\Runtime\Core\Containers\FString), [FString](API\Runtime\Core\Containers\FString) > & InKeyValues )


description: Explicitly call this function to setup syscall filters based on a file passed in from the command line -allowsyscallfilterfile=PATH_TO_FILE

code: static bool SetupSyscallFilters()


description: Ungrabs input (useful before breaking into debugging)

code: static void UngrabAllInput()


className: FUnixPlatformMisc

description: Unix implementation of the misc OS functions

code: struct FUnixPlatformMisc : public [FGenericPlatformMisc](API\Runtime\Core\GenericPlatform\FGenericPlatformMisc)


code: static const TCHAR * ApplicationSettingsDir()


code: static bool CanLaunchURL ( const TCHAR * URL )


description: Releases locks that we held for IsFirstInstance check.

code: static void CeaseBeingFirstInstance()


code: static void ClosePipe ( void * ReadPipe, void * WritePipe )


code: static void CloseProc ( [FProcHandle](API\Runtime\Core\Unix\FProcHandle) & ProcessHandle )


code: static bool CreatePipe ( void *& ReadPipe, void *& WritePipe, bool bWritePipeLocal )


code: static [FProcHandle](API\Runtime\Core\Unix\FProcHandle) CreateProc ( const TCHAR * URL, const TCHAR * Parms, bool bLaunchDetached, bool bLaunchHidden, bool bLaunchReallyHidden, uint32 * OutProcessID, int32 PriorityModifier, const TCHAR * OptionalWorkingDirectory, void * PipeWriteChild, void * PipeReadChild )


code: static [FProcHandle](API\Runtime\Core\Unix\FProcHandle) CreateProc ( const TCHAR * URL, const TCHAR * Parms, bool bLaunchDetached, bool bLaunchHidden, bool bLaunchReallyHidden, uint32 * OutProcessID, int32 PriorityModifier, const TCHAR * OptionalWorkingDirectory, void * PipeWriteChild, void * PipeReadChild, void * PipeStdErrChild )


code: static [FRunnableThread](API\Runtime\Core\HAL\FRunnableThread) * CreateRunnableThread()


code: static bool ExecProcess ( const TCHAR * URL, const TCHAR * Params, int32 * OutReturnCode, [FString](API\Runtime\Core\Containers\FString) * OutStdOut, [FString](API\Runtime\Core\Containers\FString) * OutStdErr, const TCHAR * OptionalWorkingDirectory, bool bShouldEndWithParentProcess )


code: static const TCHAR * ExecutablePath()


code: static const TCHAR * ExecutableName ( bool bRemoveExtension )


code: static void ExploreFolder ( const TCHAR * FilePath )


description: Gets current process enumerator info.

code: FProcEnumInfo GetCurrent&40;&41; const


description:
Moves current to the next process.
True if succeeded. False otherwise.

code: bool MoveNext&40;&41;


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


description: Constructor.


code: FProcEnumerator &40; const FProcEnumerator & &41;


description: Destructor.


code: namespace FUnixPlatformProcess { namespace FProcEnumerator { friend FUnixPlatformProcess&58;&58;FProcEnumerator&58;&58;FProcEnumerator&40;&41; } }


className: FProcEnumerator

description: Process enumerator.

code: class FProcEnumerator


description: Gets process full image path. I.e. full path of the exec file.

code: FString GetFullPath&40;&41; const


description: Gets process name. I.e. exec name.

code: FString GetName&40;&41; const


description: Gets parent process PID.

code: uint32 GetParentPID&40;&41; const


description: Gets process PID.

code: uint32 GetPID&40;&41; const


className: FProcEnumInfo

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

code: struct FProcEnumInfo


code: static void FreeDllHandle ( void * DllHandle )


code: static [FString](API\Runtime\Core\Containers\FString) GenerateApplicationPath ( const [FString](API\Runtime\Core\Containers\FString) & AppName, EBuildConfiguration BuildConfiguration )


code: static [FString](API\Runtime\Core\Containers\FString) GetApplicationName ( uint32 ProcessId )


code: static [FString](API\Runtime\Core\Containers\FString) GetApplicationSettingsDir ( const [ApplicationSettingsContext](API\Runtime\Core\GenericPlatform\FGenericPlatformProcess\ApplicationSetti-) & Settings )


code: static uint32 GetCurrentCoreNumber()


code: static void * GetDllHandle ( const TCHAR * Filename )


code: static void * GetDllExport ( void * DllHandle, const TCHAR * ProcName )


code: static const TCHAR * GetModuleExtension()


code: static const [FString](API\Runtime\Core\Containers\FString) GetModulesDirectory()


code: static const TCHAR * GetModulePrefix()


code: static bool GetProcReturnCode ( [FProcHandle](API\Runtime\Core\Unix\FProcHandle) & ProcHandle, int32 * ReturnCode )


code: static bool IsApplicationRunning ( const TCHAR * ProcName )


code: static bool IsApplicationRunning ( uint32 ProcessId )


code: static bool IsProcRunning ( [FProcHandle](API\Runtime\Core\Unix\FProcHandle) & ProcessHandle )


code: static bool LaunchFileInDefaultExternalApplication ( const TCHAR * FileName, const TCHAR * Parms, [ELaunchVerb::Type](API\Runtime\Core\GenericPlatform\ELaunchVerb__Type) Verb, bool bPromptToOpenOnFailure )


code: static void LaunchURL ( const TCHAR * URL, const TCHAR * Parms, [FString](API\Runtime\Core\Containers\FString) * Error )


code: static void OnChildEndFramePostFork()


code: static [FString](API\Runtime\Core\Containers\FString) ReadPipe ( void * ReadPipe )


code: static bool ReadPipeToArray ( void * ReadPipe, [TArray](API\Runtime\Core\Containers\TArray)< uint8 > & Output )


code: static bool SetProcessLimits ( [EProcessResource::Type](API\Runtime\Core\GenericPlatform\EProcessResource__Type) Resource, uint64 Limit )


code: static void SetThreadNiceValue ( uint32_t ThreadId, int32 NiceValue )


code: static void SetThreadPriority ( EThreadPriority NewPriority )


code: static void TerminateProc ( [FProcHandle](API\Runtime\Core\Unix\FProcHandle) & ProcessHandle, bool KillTree )


code: static int32 TranslateThreadPriority ( EThreadPriority Priority )


description: Like other directory functions, cannot return nullptr!

code: static const TCHAR * UserHomeDir()


code: static const TCHAR * UserName ( bool bOnlyAlphaNumeric )


code: static const TCHAR * UserSettingsDir()


code: static [FProcHandle](API\Runtime\Core\Unix\FProcHandle) OpenProcess ( uint32 ProcessID )


code: static void WaitForProc ( [FProcHandle](API\Runtime\Core\Unix\FProcHandle) & ProcessHandle )


code: static bool WritePipe ( void * WritePipe, const [FString](API\Runtime\Core\Containers\FString) & Message, [FString](API\Runtime\Core\Containers\FString) * OutWritten )


code: static bool WritePipe ( void * WritePipe, const uint8 * Data, const int32 DataLength, int32 * OutDataLength )


className: FUnixPlatformProcess

description: Unix implementation of the Process OS functions

code: struct FUnixPlatformProcess : public [FGenericPlatformProcess](API\Runtime\Core\GenericPlatform\FGenericPlatformProcess)


code: static uint32 CaptureStackBackTrace ( uint64 * BackTrace, uint32 MaxDepth, void * Context )


code: static uint32 CaptureThreadStackBackTrace ( uint64 ThreadId, uint64 * BackTrace, uint32 MaxDepth, void * Context )


code: static int32 GetProcessModuleCount()


code: static int32 GetProcessModuleSignatures ( [FStackWalkModuleInfo](API\Runtime\Core\GenericPlatform\FStackWalkModuleInfo) * ModuleSignatures, const int32 ModuleSignaturesSize )


code: static bool ProgramCounterToHumanReadableString ( int32 CurrentCallDepth, uint64 ProgramCounter, ANSICHAR * HumanReadableString, SIZE_T HumanReadableStringSize, [FGenericCrashContext](API\Runtime\Core\GenericPlatform\FGenericCrashContext) * Context )


code: static void ProgramCounterToSymbolInfo ( uint64 ProgramCounter, [FProgramCounterSymbolInfo](API\Runtime\Core\GenericPlatform\FProgramCounterSymbolInfo) & out_SymbolInfo )


code: static void StackWalkAndDump ( ANSICHAR * HumanReadableString, SIZE_T HumanReadableStringSize, int32 IgnoreCount, void * Context )


code: static void StackWalkAndDump ( ANSICHAR * HumanReadableString, SIZE_T HumanReadableStringSize, void * ProgramCounter, void * Context )


code: static void StackWalkAndDumpEx ( ANSICHAR * HumanReadableString, SIZE_T HumanReadableStringSize, int32 IgnoreCount, uint32 Flags, void * Context )


code: static void StackWalkAndDumpEx ( ANSICHAR * HumanReadableString, SIZE_T HumanReadableStringSize, void * ProgramCounter, uint32 Flags, void * Context )


code: static void ThreadStackWalkAndDump ( ANSICHAR * HumanReadableString, SIZE_T HumanReadableStringSize, int32 IgnoreCount, uint32 ThreadId )


code: template<typename CHAR> static int32 Strlen ( const CHAR * String )


className: FUnixPlatformStackWalk

code: struct FUnixPlatformStackWalk : public [FGenericPlatformStackWalk](API\Runtime\Core\GenericPlatform\FGenericPlatformStackWalk)


className: FUnixPlatformString

description: Unix string implementation

code: struct FUnixPlatformString : public [FStandardPlatformString](API\Runtime\Core\GenericPlatform\FStandardPlatformString)


className: FUnixPlatformTypes

description: Unix specific types

code: struct FUnixPlatformTypes : public [FGenericPlatformTypes](API\Runtime\Core\GenericPlatform\FGenericPlatformTypes)


description: Called at the start of a frame to register the time we are looking to detect a hitch

code: void FrameStart ( bool bSkipThisFrame )


description: Gets the heartbeat singleton

code: static [FUnixSignalGameHitchHeartBeat](API\Runtime\Core\Unix\FUnixSignalGameHitchHeartBeat) & Get()


description: Gets the heartbeat singleton

code: static [FUnixSignalGameHitchHeartBeat](API\Runtime\Core\Unix\FUnixSignalGameHitchHeartBeat) * GetNoInit()


description: Resume heartbeat hitch detection. Call only after first calling SuspendHeartBeat.

code: void ResumeHeartBeat()


className: Singleton

code: static [FUnixSignalGameHitchHeartBeat](API\Runtime\Core\Unix\FUnixSignalGameHitchHeartBeat) * Singleton = nullptr;


description: Suspend heartbeat hitch detection. Must call ResumeHeartBeat later to resume.

code: void SuspendHeartBeat()


className: FUnixSignalGameHitchHeartBeat

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

code: class FUnixSignalGameHitchHeartBeat