1. Epic GamesDeveloper
  3. Templates

Templates

API > API/Runtime > API/Runtime/Core

Classes

  Type Name Description
Public struct DefaultDeleter Deletes an object via the standard delete operator  
Public struct FConstCastTag    
Public struct FEqualityHelper    
Public class FEuclidDivisionGCD Euclidean algorithm using modulo policy.  
Public struct FFunctionRefStoragePolicy    
Public struct FFunctionStorage    
Public struct FIdentityFunctor A functor which returns whatever is passed to it. Mainly used for generic composition.  
Public class FNoncopyable Utility template for a class that should not be copyable.  
Public struct FNoopStruct Used to avoid cluttering code with ifdefs.  
Public struct FNullTag NOTE: The following is an Unreal extension to standard shared_ptr behavior.  
Public struct FRadixSortKeyFloat Float cast to uint32 which maintains sorted order http://codercorner.com/RadixSortRevisited.htm  
Public class FRefCountBase Base class implementing thread-safe reference counting.  
Public class FRefCountedObject The base class of reference counted objects.  
Public struct FSharedFromThisBase This base class only exists to implement IsDerivedFromSharedFromThis.  
Public class FSharedReferencer FSharedReferencer is a wrapper around a pointer to a reference controller that is used by either a TSharedRef or a TSharedPtr to keep track of a referenced object's lifetime  
Public struct FStaticCastTag Dummy structures used internally as template arguments for typecasts  
Public class FThreadSafeRefCountedObject Like FRefCountedObject, but internal ref count is thread safe  
Public struct FVirtualDestructor    
Public class FWeakReferencer Forward declarations.  
Public struct IDebugHelper Helper classes to help debugger visualization.  
Public struct IFunction_OwnedObject Common interface to a callable object owned by TFunction.  
Public class IRefCountedObject A virtual interface for ref counted objects to implement.  
Public struct TAlignedBytes Used to declare an untyped array of data with compile-time alignment.  
Public struct TAnd Does a boolean AND of the Value static members of each type, but short-circuits if any Type::Value == false.  
Public struct TAndValue    
Public struct TArrayRange Wraps a range into a container like interface to satisfy the GetData and GetNum global functions.  
Public class TAtomic DEPRECATED! UE atomics are not maintained and potentially will be physically deprecated.  
Public struct TAtomicBase_Arithmetic Arithmetic atomic implementation - used by both pointers and integral types in addition to getting and setting.  
Public struct TAtomicBase_Basic Basic storage and implementation - only allows getting and setting via platform atomics.  
Public struct TAtomicBase_Integral Integral atomic implementation - allows arithmetic and bitwise operations.  
Public struct TAtomicBase_Mutex TODO : basic storage and getting and setting, but the element is protected by a mutex instead of using platform atomics.  
Public struct TAtomicBase_Pointer Pointer atomic implementation - allows arithmetic with PTRINT.  
Public struct TAtomicBaseType    
Public struct TCallTraits TCallTraits  
Public struct TCallTraitsBase TRemoveConst<> is modeled after boost's implementation.  
Public struct TCallTraitsParamTypeHelper Call traits helpers  
Public class TChooseClass Chooses between two different classes based on a boolean.  
Public struct TCopyQualifiersAndRefsFromTo Copies the cv-qualifiers and references from one type to another, e.g.:  
Public struct TCopyQualifiersFromTo Copies the cv-qualifiers from one type to another, e.g.:  
Public struct TCVTupleArity    
Public struct TCVTupleElement    
Public struct TCVTupleIndex    
Public struct TDebugHelper    
Public struct TDecay Returns the decayed type of T, meaning it removes all references, qualifiers and applies array-to-pointer and function-to-pointer conversions.  
Public struct TDecayNonReference    
Public struct TDefaultDelete Single-ownership smart pointer in the vein of std::unique_ptr.  
Public struct TDeleterHolder A helper class that efficiently stores a custom deleter and is intended to be derived from.  
Public struct TDereferenceWrapper Helper class for dereferencing pointer types in Sort function  
Public struct TDontCopy Can be used as a wrapper over non-copyable objects (i.e. FCriticalSection) if you still want the class containing your object to keep its copyable property without compromising integrity of the object that doesn't support being copied.  
Public class TEnableIf Includes a function in an overload set if the predicate is true.  
Public struct TEqualTo Binary predicate class for performing equality comparisons.  
Public struct TForceInitAtBoot Template for initializing a singleton at the boot.  
Public struct TFormatSpecifier TFormatSpecifier, only applies to numeric types  
Public struct TFunction_OwnedObject    
Public struct TFunctionRefBase A class which defines an operator() which will own storage of a callable and invoke the TFunctionRefCaller::Call function on it.  
Public struct TFunctionRefCaller A class which is used to instantiate the code needed to call a bound function.  
Public struct TFunctionStorage    
Public struct TGetTupleHashHelper    
Public struct TGreater Binary predicate class for sorting elements in reverse order.  
Public struct TGuardValue Exception-safe guard around saving/restoring a value.  
Public struct TGuardValue_Bitfield_Cleanup    
Public struct TGuardValueAccessors Guard around saving/restoring a value.  
Public struct TIdentity Returns the same type passed to it.  
Public struct TImpl    
Public struct TIntegralConstant Defines a value metafunction of the given Value.  
Public class TIntrusiveReferenceController    
Public struct TInvokeResult Trait for the type of the result when invoking a callable with the given argument types.  
Public struct TInvokeResult_Impl    
Public struct TIsAbstract Traits class which tests if a type is abstract.  
Public struct TIsArithmetic Traits class which tests if a type is arithmetic.  
Public struct TIsArray Traits class which tests if a type is a C++ array.  
Public struct TIsArrayOrRefOfType Type trait which returns true if the type T is an array or a reference to an array of ArrType.  
Public struct TIsArrayOrRefOfTypeByPredicate Type trait which returns true if the type T is an array or a reference to an array of a type which matches the predicate.  
Public struct TIsBitwiseConstructible Tests if a type T is bitwise-constructible from a given argument type U.  
Public struct TIsBoundedArray Traits class which tests if a type is a bounded C++ array.  
Public struct TIsClass Determines if T is a struct/class type  
Public struct TIsConst Traits class which tests if a type is const.  
Public struct TIsConstructible Determines if T is constructible from a set of arguments.  
Public struct TIsDerivedFrom Is type DerivedType inherited from BaseType.  
Public struct TIsEnum    
Public struct TIsEnumClass Traits class which tests if a type is arithmetic.  
Public struct TIsEnumConvertibleToInt    
Public struct TIsFloatingPoint Traits class which tests if a type is floating point.  
Public struct TIsFunction TIsFunctionTests is a type is a function.  
Public struct TIsFundamentalType TIsFundamentalType  
Public struct TIsInitializerList Traits class which tests if a type is an initializer list.  
Public struct TIsIntegral Traits class which tests if a type is integral.  
Public struct TIsInvocable Traits class which tests if an instance of CallableType can be invoked with a list of the arguments of the types provided.  
Public struct TIsInvocableImpl    
Public struct TIsLValueReferenceType TIsLValueReferenceType  
Public struct TIsMemberPointer Traits class which tests if a type is a pointer to member (data member or member function).  
Public struct TIsPODType Traits class which tests if a type is POD.  
Public struct TIsPointer Traits class which tests if a type is a pointer.  
Public struct TIsPolymorphic Traits class which tests if a type is polymorphic (virtual).  
Public struct TIsReferenceType TIsReferenceType  
Public struct TIsRValueReferenceType TIsRValueReferenceType  
Public struct TIsSigned Traits class which tests if a type is a signed integral type.  
Public struct TIsSupportedSize    
Public struct TIsTFunction Traits class which checks if T is a TFunction<> type.  
Public struct TIsTFunctionRef Traits class which checks if T is a TFunctionRef<> type.  
Public struct TIsTrivial Traits class which tests if a type is trivial.  
Public struct TIsTriviallyCopyAssignable Traits class which tests if a type has a trivial copy assignment operator.  
Public struct TIsTriviallyCopyConstructible Traits class which tests if a type has a trivial copy constructor.  
Public struct TIsTUniqueFunction Traits class which checks if T is a TFunction<> type.  
Public struct TIsTuple    
Public struct TIsUECoreType Traits class which tests if a type is part of the core types included in CoreMinimal.h.  
Public struct TIsUECoreVariant Traits class which tests if a type is a core variant type (e.g. FVector, which supports FVector3f/FVector3d float/double variants. Can be used to determine if the provided type is a core variant type in general: e.g. TIsUECoreVariant::Value == false TIsUECoreVariant::Value == true and also to determine if it is a variant type of a particular component type: e.g TIsUECoreVariant::Value == false TIsUECoreVariant::Value == true  
Public struct TIsUnboundedArray Traits class which tests if a type is an unbounded C++ array.  
Public struct TIsValidVariadicFunctionArg Tests if a type is a valid argument to a variadic function, e.g. printf.  
Public struct TIsVoidPointer    
Public struct TIsWeakPointerType TIsWeakPointerType  
Public struct TIsZeroConstructType TIsZeroConstructType  
Public class TJugglingRotation Array rotation using juggling technique.  
Public struct TKeyValuePair Helper class to make it easy to use key/value pairs with a container.  
Public class TLazyEnableIf This is a variant of the above that will determine the return type 'lazily', i.e. only if the function is enabled.  
Public struct TLess Binary predicate class for sorting elements in order.  
Public struct TLessThanHelper    
Public struct TLosesQualifiersFromTo Tests if qualifiers are lost between one type and another, e.g.:  
Public struct TMakeSigned Traits class which gets the signed version of an integer type.  
Public struct TMakeUnsigned Traits class which gets the unsigned version of an integer type.  
Public struct TMaxSizeof Finds the maximum sizeof the supplied types  
Public class TMergeSort Merge sort class.  
Public struct TModels Traits class which does concept checking.  
Public struct TMoveSupportTraits This traits class is intended to be used in pairs to allow efficient and correct move-aware overloads for generic types.  
Public struct TMoveSupportTraitsBase    
Public struct TNameOf TNameOf  
Public class TNonNullPtr TNonNullPtr is a non-nullable, non-owning, raw/naked/unsafe pointer.  
Public struct TNot Does a boolean NOT of the Value static members of the type.  
Public struct TNthTypeFromParameterPack TIsSame  
Public struct TOptionalGuardValue Exception-safe guard around saving/restoring a value.  
Public struct TOr Does a boolean OR of the Value static members of each type, but short-circuits if any Type::Value == true.  
Public struct TOrValue    
Public struct TPimplHeapObjectImpl    
Public struct TPimplPtr Forward declaration.  
Public struct TPointerIsConvertibleFromTo Tests if a From* is convertible to a To*  
Public class TPointerIsConvertibleFromTo_TestBase    
Public class TPointerIsConvertibleFromTo_TestDerived    
Public class TPointerIsConvertibleFromTo_Unrelated    
Public struct TPtrVariantBase    
Public struct TRadixSortKeyCastUint32    
Public struct TRawPtrProxy NOTE: The following is an Unreal extension to standard shared_ptr behavior.  
Public struct TRawPtrProxyWithDeleter NOTE: The following is an Unreal extension to standard shared_ptr behavior.  
Public class TRefCountingMixin Ref-counting mixin, designed to add ref-counting to an object without requiring a virtual destructor.  
Public class TRefCountPtr A smart pointer to an object which implements AddRef/Release.  
Public class TReferenceControllerBase    
Public class TReferenceControllerWithDeleter    
Public struct TRemoveExtent Removes one dimension of extents from an array type.  
Public struct TRemovePointer Removes one level of pointer from a type, e.g.:  
Public struct TRemoveReference TRemoveReference will remove any references from a type.  
Public struct TRetainedRef TRetainedRef  
Public class TReversePredicate Helper class to reverse a predicate. Performs Predicate(B, A)  
Public class TRotationInPlaceMerge Merge policy for merge sort.  
Public struct TRValueToLValueReference TRValueToLValueReference converts any rvalue reference type into the equivalent lvalue reference, otherwise returns the same type.  
Public struct TScopeCounter Commonly used to make sure a value is incremented, and then decremented anyway the function can terminate.  
Public class TScopedCallback Helper object for batching callback requests and firing on destruction of the FScopedCallback object.  
Public class TSharedFromThis Derive your class from TSharedFromThis to enable access to a TSharedRef directly from an object instance that's already been allocated.  
Public class TSharedPtr TSharedPtr is a non-intrusive reference-counted authoritative object pointer.  
Public class TSharedRef NOTE: TSharedRef is an Unreal extension to standard smart pointer feature set.  
Public struct TStrongPtrVariant [TStrongPtrVariant](API\Runtime\Core\Templates\TStrongPtrVariant)_ will be either a TStrongObjectPtr or `TSharedPtr  
Public struct TTransformTuple_Impl    
Public struct TTuple    
Public struct TTupleArity Traits class which calculates the number of elements in a tuple.  
Public struct TTupleBase    
Public struct TTupleBaseElement    
Public struct TTupleElementGetterByIndex    
Public struct TTupleElementGetterByType    
Public struct TTypeCompatibleBytes An untyped array of data with compile-time alignment and size derived from another type.  
Public struct TTypeTraits Traits for types.  
Public struct TTypeTraitsBase Helper for array traits.  
Public class TUniqueFunction TUniqueFunctionSee the class definition for intended usage.  
Public class TUniqueObj This is essentially a reference version of TUniquePtr Useful to force heap allocation of a value, e.g. in a TMap to give similar behaviour to TIndirectArray  
Public class TUniquePtr    
Public class TValueOrError Type used to return either a value or an error.  
Public struct TValueOrError_ErrorProxy    
Public struct TValueOrError_ValueProxy    
Public struct TVisitTupleElements_Impl    
Public struct TVoid    
Public class TWeakPtr TWeakPtr is a non-intrusive reference-counted weak object pointer.  
Public struct TWeakPtrVariant [TWeakPtrVariant](API\Runtime\Core\Templates\TWeakPtrVariant)_ and TStrongPtrVariant are particularly useful for "interfaces" in areas where UObjects and non-UObjects exist to hold onto a "smart" pointer to the Interface, rather than needing to keep track of the implementing class to check validity and manually cast [TWeakPtrVariant](API\Runtime\Core\Templates\TWeakPtrVariant)_ will be either a TWeakObjectPtr or `TWeakPtr_  

Typedefs

Name Description
FCopyFunc  
FDeleteFunc  
TAtomicBaseType_T  
TCopyQualifiersAndRefsFromTo_T  
TFuncPtrTypeIfPossible_T  
TIdentity_T  
TInvokeResult_T  
TTupleElement Traits class which gets the element type of a TTuple with the given index.
TTupleIndex Traits class which gets the tuple index of a given type from a given TTuple.
TUnderlyingIntegerType_T  

Enums

  Type Name Description
Public enum EDefaultConstructNonNullPtr    
Public enum EMemoryOrder    
Public enum EPimplPtrMode Single-ownership smart pointer similar to TUniquePtr but with a few differences which make it particularly useful for (but not limited to) implementing the pimpl pattern:  
Public enum ERefCountingMode ERefCountingMode is used select between either 'fast' or 'thread safe' ref-counting types.  
Public enum ESPMode ESPMode is used select between either 'fast' or 'thread safe' shared pointer types.  
Public enum UE::Core::Private::Tuple::EForwardingConstructor    
Public enum UE::Core::Private::Tuple::EOtherTupleConstructor    

Functions

  Type Name Description
Public function T

Align ( T Val,
uint64 Alignment
)

 Aligns a value to the nearest higher multiple of 'Alignment', which must be a power of two.
Public function T

AlignArbitrary ( T Val,
uint64 Alignment
)

 Aligns a value to the nearest higher multiple of 'Alignment'.
Public function T

AlignDown ( T Val,
uint64 Alignment
)

 Aligns a value to the nearest lower multiple of 'Alignment', which must be a power of two.
Public function const T(&

AsConst ( T(&) Array
)

 Returns a non-const reference type as const.
Public function void

AsConst ( const T&& Ref
)

 Disallowed for rvalue references because it cannot extend their lifetime.
Public function const T &

AsConst ( T& Ref
)

 Returns a non-const reference type as const.
Public function ToType

BitCast ( const FromType& From
)

  
Public function T

BitMask ( uint32 Count
)

 Generates a bitmask with a given number of bits set.
Public function void

CleanupPointerArray ( TArray< TWeakPtr< Type > >& PointerArray
)

 Given a TArray of TWeakPtr's, will remove any invalid pointers.
Public function void

CleanupPointerMap ( TMap< TWeakPtr< KeyType >, ValueType >& PointerMap
)

 Given a TMap of TWeakPtr's, will remove any invalid pointers.
Public function bool

CompareItems ( const ElementType* A,
const ElementType* B,
SizeType Count
)

  
Public function TSharedPtr< CastToType, Mode >

ConstCastSharedPtr ( TSharedPtr< CastFromType, Mode > const& InSharedPtr
)

 Casts a 'const' shared pointer to 'mutable' shared pointer. (const_cast)
Public function TSharedRef< CastToType, Mode >

ConstCastSharedRef ( TSharedRef< CastFromType, Mode > const& InSharedRef
)

 Casts a 'const' shared reference to 'mutable' shared reference. (const_cast)
Public function TWeakPtr< CastToType, Mode >

ConstCastWeakPtr ( TWeakPtr< CastFromType, Mode > const& InWeakPtr
)

 Casts a 'const' weak pointer to 'mutable' weak pointer. (const_cast)
Public function void

ConstructItems ( void* Dest,
const SourceElementType* Source,
SizeType Count
)

 Constructs a range of items into memory from a set of arguments.
Public function void

CopyAssignItems ( ElementType* Dest,
const ElementType* Source,
SizeType Count
)

 Copy assigns a range of items.
Public function T

CopyTemp ( const T& Val
)

  
Public function T

CopyTemp ( T& Val
)

 CopyTemp will enforce the creation of a prvalue which can bind to rvalue reference parameters.
Public function std::decay_t< T >

CopyTempIfNecessary ( T&& Val
)

 CopyTempIfNecessary will enforce the creation of a prvalue.
Public function T &&

DeclVal ()

 Equivalent to std::declval.
Public function void

DefaultConstructItems ( void* Address,
SizeType Count
)

 Default constructs a range of items in memory.
Public function void

DestructItem ( ElementType* Element
)

 Destructs a single item in memory.
Public function void

DestructItems ( ElementType* Element,
SizeType Count
)

 Destructs a range of items in memory.
Public function void

Exchange ( T& A,
T& B
)

  
Public function OutType

FloatCastChecked ( InType In,
InType Precision
)

  
Public function bool

FloatFitsIn ( InType In,
InType Precision
)

 Test if value can make a static_cast roundtrip via OutType whilst maintaining precision
Public function T &&

Forward ( std::remove_reference_t< T >& Obj
)

 Forward will cast a reference to an rvalue reference. This is UE's equivalent of std::forward.
Public function T &&

Forward ( std::remove_reference_t< T >&& Obj
)

  
Public function decltype(auto)

ForwardAsBase ( std::remove_reference_t< T >& Obj
)

 ForwardAsBase will cast a reference to an rvalue reference of a base type.
Public function decltype(auto)

ForwardAsBase ( std::remove_reference_t< T >&& Obj
)

  
Public function TTuple< Types &&... >

ForwardAsTuple ( Types&&... Args
)

 Makes a TTuple from some arguments.
Public function uint32

Freeze::IntrinsicAppendHash ( const TTuple< KeyType, ValueType >* DummyObject,
const FTypeLayoutDesc& TypeDesc,
const FPlatformTypeLayoutParameters& LayoutParams,
FSHA1& Hasher
)

  
Public function uint32

Freeze::IntrinsicGetTargetAlignment ( const TTuple< KeyType, ValueType >* DummyObject,
const FTypeLayoutDesc& TypeDesc,
const FPlatformTypeLayoutParameters& LayoutParams
)

  
Public function uint32

Freeze::IntrinsicUnfrozenCopy ( const FMemoryUnfreezeContent& Context,
const TTuple< KeyType, ValueType >& Object,
void* OutDst
)

  
Public function void

Freeze::IntrinsicWriteMemoryImage ( FMemoryImageWriter& Writer,
const TTuple< KeyType, ValueType >& Object,
const FTypeLayoutDesc&
)

  
Public function void

Freeze::IntrinsicWriteMemoryImage ( FMemoryImageWriter& Writer,
const TSharedPtr< ObjectType, Mode >& Object,
const FTypeLayoutDesc&
)

  
Public function decltype(auto)

get ( TupleType&& val
)

  
Public function uint32

GetArrayHash ( const T* Ptr,
uint64 Size,
uint32 PreviousHash
)

  
Public function decltype(Container.GetData())

GetData ( T&& Container
)

 Generically gets the data pointer of a contiguous container
Public function T *

GetData ( T(&&) Container
)

  
Public function const T *

GetData ( const T(&) Container
)

  
Public function const T *

GetData ( std::initializer_list< T > List
)

  
Public function T *

GetData ( T(&) Container
)

  
Public function const T *

GetData ( const T(&&) Container
)

  
Public function SIZE_T

GetNum ( const T(&&) Container
)

  
Public function int32

GetNum ( std::initializer_list< T > List
)

 Gets the number of items in an initializer list.
Public function SIZE_T

GetNum ( const T(&) Container
)

  
Public function SIZE_T

GetNum ( T(&&) Container
)

  
Public function SIZE_T

GetNum ( T(&) Container
)

  
Public function decltype(Container.Num())

GetNum ( T&& Container
)

 Generically gets the number of items in a contiguous container
Public function ObjectType *

GetRawPointerOrNull ( const TOptional< gsl::not_null< ObjectType* > >& Optional
)

 Utility function to turn an `TOptional>_ back into a nullable T.
Public function ObjectType *

GetRawPointerOrNull ( const TOptional< TNonNullPtr< ObjectType > >& Optional
)

 Convenience function to turn an `TOptional<TNonNullPtr>_ back into a nullable T*
Public function ObjectType *

GetRawPointerOrNull ( const TOptional< gsl::strict_not_null< ObjectType* > >& Optional
)

 Utility function to turn an `TOptional>_ back into a nullable T.
Public function uint32

GetTypeHash ( ScalarType Value
)

 Hash functions for common types.
Public function uint32

GetTypeHash ( const TRefCountPtr< ReferencedType >& InPtr
)

  
Public function uint32

GetTypeHash ( const TSharedRef< ObjectType, Mode >& InSharedRef
)

 Computes a hash code for this object
Public function uint32

GetTypeHash ( const TSharedPtr< ObjectType, Mode >& InSharedPtr
)

 Computes a hash code for this object
Public function uint32

GetTypeHash ( const TWeakPtr< ObjectType, Mode >& InWeakPtr
)

 Computes a hash code for this object
Public function uint32

GetTypeHash ( const TTuple< Types... >& Tuple
)

  
Public function uint32

GetTypeHash ( const TTuple<>& Tuple
)

  
Public function uint32

GetTypeHash ( T(&) Array
)

  
Public function decltype(GetTypeHash(*NotNull))

GetTypeHash ( const gsl::strict_not_null< ObjectType >& NotNull
)

 Utility function to hash a `gsl::strict_not_null_.
Public function decltype(GetTypeHash(*NotNull))

GetTypeHash ( const gsl::not_null< ObjectType >& NotNull
)

 Utility function to hash a `gsl::not_null_.
Public function uint32

GetTypeHash ( T* Value
)

  
Public function uint32

GetTypeHashHelper ( const T& V
)

 Use this when inside type that has GetTypeHash() (no in-parameters) implemented. It makes GetTypeHash dispatch in global namespace.
Public function uint32 Combines two hash values to get a third.
Public function uint32 Combines two hash values to get a third.
Public function ReferencedType *

IfAThenAElseB ( ReferencedType* A,
ReferencedType* B
)

 Chooses between the two parameters based on whether the first is nullptr or not.
Public function ReferencedType *

IfPThenAElseB ( PredicateType Predicate,
ReferencedType* A,
ReferencedType* B
)

 Branchless pointer selection based on predicate return PTRINT(Predicate) ? A : B;
Public function T

ImplicitConv ( typename TIdentity< T >::Type Obj
)

 Uses implicit conversion to create an instance of a specific type.
Public function OutType

IntCastChecked ( InType In
)

 Cast and check that value fits in OutType
Public function bool

IntFitsIn ( InType In
)

 Test if value can make a lossless static_cast roundtrip via OutType without a sign change
Public function decltype(Forward< FuncType >(Func)(Forward< ArgTypes >(Args)...))

Invoke ( FuncType&& Func,
ArgTypes&&... Args
)

 Invokes a callable with a set of arguments.
Public function decltype(UE::Core::Private::DereferenceIfNecessary< ObjType >(Forward< TargetType >(Target), &Target...

Invoke ( ReturnType ObjType::* pdm,
TargetType&& Target
)

  
Public function decltype((UE::Core::Private::DereferenceIfNecessary< ObjType >(Forward< TargetType >(Target), &Targe...

Invoke ( PtrMemFunType PtrMemFun,
TargetType&& Target,
ArgTypes&&... Args
)

  
Public function bool

IsAligned ( T Val,
uint64 Alignment
)

 Checks if a pointer is aligned to the specified alignment.
Public function bool  
Public function TValueOrError_ErrorProxy< ArgTypes... >

MakeError ( ArgTypes&&... Args
)

  
Public function TPimplPtr< T, Mode >

MakePimpl ( ArgTypes&&... Args
)

 Heap-allocates an instance of T with the given arguments and returns it as a TPimplPtr.
Public function TRefCountPtr< T >

MakeRefCount ( TArgs&&... Args
)

  
Public function SharedPointerInternals::TRawPtrProxy< ObjectType >

MakeShareable ( ObjectType* InObject
)

 NOTE: The following is an Unreal extension to standard shared_ptr behavior.
Public function SharedPointerInternals::TRawPtrProxyWithDeleter< ObjectType, DeleterType >

MakeShareable ( ObjectType* InObject,
DeleterType&& InDeleter
)

 NOTE: The following is an Unreal extension to standard shared_ptr behavior.
Public function TSharedRef< InObjectType, InMode >

MakeShared ( InArgTypes&&... Args
)

 MakeShared utility function.
Public function TTuple< std::decay_t< Types >... >

MakeTuple ( Types&&... Args
)

 Makes a TTuple from some arguments.
Public function TUniquePtr< T >

MakeUnique ( SIZE_T Size
)

 Allocates a new array of type T with the given size and returns it as a TUniquePtr.
Public function TUniquePtr< T >

MakeUnique ( TArgs&&... Args
)

 Allocates a new object of type T with the given arguments and returns it as a TUniquePtr.
Public function TUniquePtr< T > Allocates a new object of type T with the given arguments and returns it as a TUniquePtr.
Public function TUniquePtr< T > Allocates a new array of type T with the given size and returns it as a TUniquePtr.
Public function TValueOrError_ValueProxy< ArgTypes... >

MakeValue ( ArgTypes&&... Args
)

  
Public function ForwardIt

MaxElement ( ForwardIt First,
ForwardIt Last,
PredicateType Predicate
)

 Works just like std::max_element.
Public function ForwardIt

MaxElement ( ForwardIt First,
ForwardIt Last
)

 Works just like std::max_element.
Public function void

Merge ( T* Out,
T* In,
const int32 Mid,
const int32 Num,
const PREDICATE_CLASS& Predicate
)

 Stable merge to perform sort below. Stable sort is slower than non-stable algorithm.
Public function ForwardIt

MinElement ( ForwardIt First,
ForwardIt Last,
PredicateType Predicate
)

 Works just like std::min_element.
Public function ForwardIt

MinElement ( ForwardIt First,
ForwardIt Last
)

 Works just like std::min_element.
Public function void

Move ( T& A,
typename TMoveSupportTraits< T >::Copy B
)

 This is used to provide type specific behavior for a copy which cannot change the value of B.
Public function void

Move ( T& A,
typename TMoveSupportTraits< T >::Move B
)

 This is used to provide type specific behavior for a move which may change the value of B.
Public function void

MoveAssignItems ( ElementType* Dest,
const ElementType* Source,
SizeType Count
)

 Move assigns a range of items.
Public function void

MoveConstructItems ( void* Dest,
const ElementType* Source,
SizeType Count
)

 Move constructs a range of items into memory.
Public function std::remove_reference_t< T > &&

MoveTemp ( T&& Obj
)

 MoveTemp will cast a reference to an rvalue reference.
Public function std::remove_reference_t< T > &&

MoveTempIfPossible ( T&& Obj
)

 MoveTempIfPossible will cast a reference to an rvalue reference.
Public function bool

operator!= ( TYPE_OF_NULLPTR,
const TFunction< FuncType >& Func
)

 Nullptr inequality operator.
Public function bool

operator!= ( TYPE_OF_NULLPTR,
const TPimplPtr< T, Mode >& Ptr
)

  
Public function bool

operator!= ( const UE::Core::Private::TPtrVariantBase< LhsType, bLhsStrength >& Lhs,
const UE::Core::Private::TPtrVariantBase< RhsType, bRhsStrength >& Rhs
)

  
Public function bool

operator!= ( LhsType* Lhs,
const UE::Core::Private::TPtrVariantBase< RhsType, bRhsStrength >& Rhs
)

  
Public function bool

operator!= ( TSharedRef< ObjectTypeA, Mode > const& InSharedRefA,
TSharedRef< ObjectTypeB, Mode > const& InSharedRefB
)

 Global inequality operator for TSharedRef
Public function bool

operator!= ( TSharedPtr< ObjectTypeA, Mode > const& InSharedPtrA,
TSharedPtr< ObjectTypeB, Mode > const& InSharedPtrB
)

 Global inequality operator for TSharedPtr
Public function bool

operator!= ( TSharedPtr< ObjectTypeA, Mode > const& InSharedPtrA,
TYPE_OF_NULLPTR
)

 Global inequality operator for TSharedPtr
Public function bool

operator!= ( TYPE_OF_NULLPTR,
TSharedPtr< ObjectTypeB, Mode > const& InSharedPtrB
)

 Global inequality operator for TSharedPtr
Public function bool

operator!= ( TSharedPtr< ObjectTypeB, Mode > const& InSharedPtr,
TSharedRef< ObjectTypeA, Mode > const& InSharedRef
)

 Tests to see if a TSharedRef is not "equal" to a TSharedPtr (shared pointer is invalid, or both refer to different objects) (reverse)
Public function bool

operator!= ( TWeakPtr< ObjectTypeA, Mode > const& InWeakPtrA,
TWeakPtr< ObjectTypeB, Mode > const& InWeakPtrB
)

 Global inequality operator for TWeakPtr
Public function bool

operator!= ( TWeakPtr< ObjectTypeA, Mode > const& InWeakPtrA,
TSharedPtr< ObjectTypeB, Mode > const& InSharedPtrB
)

 Global equality operator for TWeakPtr
Public function bool

operator!= ( TSharedRef< ObjectTypeA, Mode > const& InSharedRefA,
TWeakPtr< ObjectTypeB, Mode > const& InWeakPtrB
)

 Global equality operator for TWeakPtr
Public function bool

operator!= ( TSharedPtr< ObjectTypeA, Mode > const& InSharedPtrA,
TWeakPtr< ObjectTypeB, Mode > const& InWeakPtrB
)

 Global equality operator for TWeakPtr
Public function bool

operator!= ( TWeakPtr< ObjectTypeA, Mode > const& InWeakPtrA,
TYPE_OF_NULLPTR
)

 Global inequality operator for TWeakPtr
Public function bool

operator!= ( TYPE_OF_NULLPTR,
TWeakPtr< ObjectTypeB, Mode > const& InWeakPtrB
)

 Global inequality operator for TWeakPtr
Public function bool

operator!= ( TYPE_OF_NULLPTR,
const TUniquePtr< T >& Rhs
)

  
Public function bool

operator!= ( TSharedRef< ObjectTypeA, Mode > const& InSharedRef,
TSharedPtr< ObjectTypeB, Mode > const& InSharedPtr
)

 Tests to see if a TSharedRef is not "equal" to a TSharedPtr (shared pointer is invalid, or both refer to different objects)
Public function bool

operator!= ( TWeakPtr< ObjectTypeA, Mode > const& InWeakPtrA,
TSharedRef< ObjectTypeB, Mode > const& InSharedRefB
)

 Global equality operator for TWeakPtr
Public function bool

operator!= ( const UE::Core::Private::TPtrVariantBase< LhsType, bLhsStrength >& Lhs,
RhsType* Rhs
)

  
Public function bool

operator== ( TSharedRef< ObjectTypeA, Mode > const& InSharedRefA,
TWeakPtr< ObjectTypeB, Mode > const& InWeakPtrB
)

 Global equality operator for TWeakPtr
Public function bool

operator== ( TSharedPtr< ObjectTypeB, Mode > const& InSharedPtr,
TSharedRef< ObjectTypeA, Mode > const& InSharedRef
)

 Tests to see if a TSharedRef is "equal" to a TSharedPtr (both are valid and refer to the same object) (reverse)
Public function bool

operator== ( TSharedRef< ObjectTypeA, Mode > const& InSharedRef,
TSharedPtr< ObjectTypeB, Mode > const& InSharedPtr
)

 Tests to see if a TSharedRef is "equal" to a TSharedPtr (both are valid and refer to the same object)
Public function bool

operator== ( TYPE_OF_NULLPTR,
TSharedPtr< ObjectTypeB, Mode > const& InSharedPtrB
)

 Global equality operator for TSharedPtr
Public function bool

operator== ( TSharedPtr< ObjectTypeA, Mode > const& InSharedPtrA,
TYPE_OF_NULLPTR
)

 Global equality operator for TSharedPtr
Public function bool

operator== ( TYPE_OF_NULLPTR,
const TUniquePtr< T >& Rhs
)

  
Public function bool

operator== ( TYPE_OF_NULLPTR,
TWeakPtr< ObjectTypeB, Mode > const& InWeakPtrB
)

 Global equality operator for TWeakPtr
Public function bool

operator== ( TWeakPtr< ObjectTypeA, Mode > const& InWeakPtrA,
TSharedPtr< ObjectTypeB, Mode > const& InSharedPtrB
)

 Global equality operator for TWeakPtr
Public function bool

operator== ( TWeakPtr< ObjectTypeA, Mode > const& InWeakPtrA,
TYPE_OF_NULLPTR
)

 Global equality operator for TWeakPtr
Public function bool

operator== ( TYPE_OF_NULLPTR,
const TFunction< FuncType >& Func
)

 Nullptr equality operator.
Public function bool

operator== ( TYPE_OF_NULLPTR,
const TPimplPtr< T, Mode >& Ptr
)

  
Public function bool

operator== ( const UE::Core::Private::TPtrVariantBase< LhsType, bLhsStrength >& Lhs,
const UE::Core::Private::TPtrVariantBase< RhsType, bRhsStrength >& Rhs
)

  
Public function bool

operator== ( LhsType* Lhs,
const UE::Core::Private::TPtrVariantBase< RhsType, bRhsStrength >& Rhs
)

  
Public function bool

operator== ( const UE::Core::Private::TPtrVariantBase< LhsType, bLhsStrength >& Lhs,
RhsType* Rhs
)

  
Public function bool

operator== ( ReferencedType* A,
const TRefCountPtr< ReferencedType >& B
)

  
Public function bool

operator== ( TSharedPtr< ObjectTypeA, Mode > const& InSharedPtrA,
TWeakPtr< ObjectTypeB, Mode > const& InWeakPtrB
)

 Global equality operator for TWeakPtr
Public function bool

operator== ( TSharedRef< ObjectTypeA, Mode > const& InSharedRefA,
TSharedRef< ObjectTypeB, Mode > const& InSharedRefB
)

 Global equality operator for TSharedRef
Public function bool

operator== ( TSharedPtr< ObjectTypeA, Mode > const& InSharedPtrA,
TSharedPtr< ObjectTypeB, Mode > const& InSharedPtrB
)

 Global equality operator for TSharedPtr
Public function bool

operator== ( TWeakPtr< ObjectTypeA, Mode > const& InWeakPtrA,
TSharedRef< ObjectTypeB, Mode > const& InSharedRefB
)

 Global equality operator for TWeakPtr
Public function bool

operator== ( TWeakPtr< ObjectTypeA, Mode > const& InWeakPtrA,
TWeakPtr< ObjectTypeB, Mode > const& InWeakPtrB
)

 Global equality operator for TWeakPtr
Public function uint32

PointerHash ( const void* Key
)

  
Public function uint32

PointerHash ( const void* Key,
uint32 C
)

  
Public function void

RadixSort32 ( ValueType*__restrict Dst,
ValueType*__restrict Src,
CountType Num
)

  
Public function void

RadixSort32 ( ValueType*__restrict Dst,
ValueType*__restrict Src,
CountType Num,
const SortKeyClass& SortKey
)

 Very fast 32bit radix sort.
Public function void

RadixSort32 ( float*__restrict Dst,
float*__restrict Src,
CountType Num
)

  
Public function int(&)[!!TModels_V< Concept, Args... > *2 - 1]

Refines ()

 Helper function which can be used as an expression in a concept to refine ('inherit') another concept.
Public function void

RelocateConstructItem ( void* Dest,
const SourceElementType* Source
)

 Relocates a single items to a new memory location as a new type.
Public function void

RelocateConstructItems ( void* Dest,
SourceElementType* Source,
SizeType Count
)

 Relocates a range of items to a new memory location as a new type.
Public function T

ReverseBits ( T Bits
)

 Reverses the order of the bits of a value.
Public function void

SharedPointerInternals::EnableSharedFromThis ( SharedPtrType* InSharedPtrOrRef,
ObjectType const* InObject
)

 Templated helper function (const) that creates a shared pointer from an object instance
Public function TReferenceControllerBase< Mode > *

SharedPointerInternals::NewCustomReferenceController ( ObjectType* Object,
DeleterType&& Deleter
)

 Creates a custom reference controller with a specified deleter
Public function TReferenceControllerBase< Mode > * Creates a reference controller which just calls delete
Public function TIntrusiveReferenceController< ObjectType, Mode > * Creates an intrusive reference controller
Public function void

Sort ( T** First,
const int32 Num
)

 Specialized version of the above Sort function for pointers to elements.
Public function void

Sort ( T* First,
const int32 Num
)

 Sort elements.
Public function void

Sort ( T* First,
const int32 Num,
const PREDICATE_CLASS& Predicate
)

 Sort elements using user defined predicate class.
Public function void

Sort ( T** First,
const int32 Num,
const PREDICATE_CLASS& Predicate
)

 Specialized version of the above Sort function for pointers to elements.
Public function void

StableSort ( T* First,
const int32 Num
)

 Stable sort elements.
Public function void

StableSort ( T** First,
const int32 Num
)

 Specialized version of the above StableSort function for pointers to elements.
Public function void

StableSort ( T** First,
const int32 Num,
const PREDICATE_CLASS& Predicate
)

 Specialized version of the above StableSort function for pointers to elements.
Public function void

StableSort ( T* First,
const int32 Num,
const PREDICATE_CLASS& Predicate
)

 Stable sort elements using user defined predicate class.
Public function void

StableSortInternal ( T* First,
const int32 Num,
const PREDICATE_CLASS& Predicate
)

 Stable sort elements using user defined predicate class.
Public function T

StaticCast ( ArgType&& Arg
)

 This exists to avoid a Visual Studio bug where using a cast to forward an rvalue reference array argument to a pointer parameter will cause bad code generation.
Public function TSharedPtr< CastToType, Mode >

StaticCastSharedPtr ( TSharedPtr< CastFromType, Mode > const& InSharedPtr
)

 Casts a shared pointer of one type to another type. (static_cast) Useful for down-casting.
Public function TSharedRef< CastToType, Mode >

StaticCastSharedRef ( TSharedRef< CastFromType, Mode > const& InSharedRef
)

 SharedPointerInternals.h contains the implementation of reference counting structures we need.
Public function TWeakPtr< CastToType, Mode >

StaticCastWeakPtr ( TWeakPtr< CastFromType, Mode > const& InWeakPtr
)

 Casts a weak pointer of one type to another type. (static_cast) Useful for down-casting.
Public function void

Swap ( T& A,
T& B
)

 Swap two values. Assumes the types are trivially relocatable.
Public function TTuple< Types &... >

Tie ( Types&... Args
)

 Tie function for structured unpacking of tuples into individual variables.
Public function decltype(auto)

TransformTuple ( TTuple< Types... >&& Tuple,
FuncType Func
)

 Creates a new TTuple by applying a functor to each of the elements.
Public function decltype(auto)

TransformTuple ( const TTuple< Types... >& Tuple,
FuncType Func
)

  
Public function T *

UE::Core::Private::Atomic::AddExchange ( T*volatile* Element,
DiffType Diff
)

  
Public function T

UE::Core::Private::Atomic::AddExchange ( volatile T* Element,
DiffType Diff
)

  
Public function T

UE::Core::Private::Atomic::AndExchange ( volatile T* Element,
T AndValue
)

  
Public function T

UE::Core::Private::Atomic::CompareExchange ( volatile T* Element,
T ExpectedValue,
T NewValue
)

  
Public function T *  
Public function T  
Public function T

UE::Core::Private::Atomic::Exchange ( volatile T* Element,
T Value
)

  
Public function T *  
Public function T  
Public function T

UE::Core::Private::Atomic::Load ( const volatile T* Element
)

  
Public function T

UE::Core::Private::Atomic::LoadRelaxed ( const volatile T* Element
)

  
Public function T

UE::Core::Private::Atomic::OrExchange ( volatile T* Element,
T OrValue
)

  
Public function void

UE::Core::Private::Atomic::Store ( const volatile T* Element,
T Value
)

  
Public function void

UE::Core::Private::Atomic::StoreRelaxed ( const volatile T* Element,
T Value
)

  
Public function T *

UE::Core::Private::Atomic::SubExchange ( T*volatile* Element,
DiffType Diff
)

  
Public function T

UE::Core::Private::Atomic::SubExchange ( volatile T* Element,
DiffType Diff
)

  
Public function T

UE::Core::Private::Atomic::XorExchange ( volatile T* Element,
T XorValue
)

  
Public function decltype((TargetType &&) Target)

UE::Core::Private::DereferenceIfNecessary ( TargetType&& Target,
const volatile OuterType* TargetPtr
)

  
Public function decltype(*(TargetType &&) Target)

UE::Core::Private::DereferenceIfNecessary ( TargetType&& Target,
...
)

  
Public function bool  
Public function decltype(+std::declval< FunctorType >())  
Public function FunctorType &&  
Public function T &&  
Public function TSharedRef< ObjectType, Mode >

UE::Core::Private::MakeSharedRef ( ObjectType* InObject,
SharedPointerInternals::TReferenceControllerBase< Mode >* InSharedReferenceCount
)

 Needed to work around an Android compiler bug - we need to construct a TSharedRef from MakeShared without making MakeShared a friend in order to access the private constructor.
Public function Static char(&  
Public function Static char(&

UE::Core::Private::ModelsResolve ( decltype&::< ... >Ts*
)

  
Public function void *  
Public function void  
Public function Static void *  
Public function void  
Public function Static void

UE::Core::Private::Tuple::Assign ( LhsType& Lhs,
RhsType&& Rhs,
TIntegerSequence< uint32, Indices... >
)

  
Public function decltype(ConceptCheckingHelper((DeclVal< Given >()=DeclVal< Deduced && >(), 0)...))  
Public function void This only exists to have something to expand a parameter pack into, for concept checking.
Public function std::enable_if_t< std::conjunction_v< std::is_constructible< Given, Deduced && >... > >  
Public function TTuple< ElementTypes... >  
Public function uint32  
Public function char(&

UEArrayCountHelper ( const T
)

  
Public function void

VisitTupleElements ( FuncType&& Func,
FirstTupleType&& FirstTuple,
TupleTypes&&... Tuples
)

 Visits each element in the specified tuples in parallel and applies them as arguments to the functor.
Public function bool

XOR ( bool A,
bool B
)

 A logical exclusive or function.

Variables

  Type Name Description
Public variable SIZE_T RequiredAlignment  
Public variable bool TCanBitwiseRelocate_V  
Public variable T TForceConstEval_V  
Public variable bool TIsTSharedPtr_V Trait which determines whether or not a type is a TSharedPtr.
Public variable bool TIsTSharedPtr_V< const TSharedPtr< ObjectType, InMode > >  
Public variable bool TIsTSharedPtr_V< const volatile TSharedPtr< ObjectType, InMode > >  
Public variable bool TIsTSharedPtr_V< TSharedPtr< ObjectType, InMode > >  
Public variable bool TIsTSharedPtr_V< volatile TSharedPtr< ObjectType, InMode > >  
Public variable bool TIsTSharedRef_V Trait which determines whether or not a type is a TSharedRef.
Public variable bool TIsTSharedRef_V< const TSharedRef< ObjectType, InMode > >  
Public variable bool TIsTSharedRef_V< const volatile TSharedRef< ObjectType, InMode > >  
Public variable bool TIsTSharedRef_V< TSharedRef< ObjectType, InMode > >  
Public variable bool TIsTSharedRef_V< volatile TSharedRef< ObjectType, InMode > >  
Public variable bool TIsTUniqueObj_V Trait which determines whether or not a type is a TUniqueObj.
Public variable bool TIsTUniqueObj_V< const TUniqueObj< T > >  
Public variable bool TIsTUniqueObj_V< const volatile TUniqueObj< T > >  
Public variable bool TIsTUniqueObj_V< TUniqueObj< T > >  
Public variable bool TIsTUniqueObj_V< volatile TUniqueObj< T > >  
Public variable bool TIsTUniquePtr_V Trait which determines whether or not a type is a TUniquePtr.
Public variable bool TIsTUniquePtr_V< const TUniquePtr< T, Deleter > >  
Public variable bool TIsTUniquePtr_V< const volatile TUniquePtr< T, Deleter > >  
Public variable bool TIsTUniquePtr_V< TUniquePtr< T, Deleter > >  
Public variable bool TIsTUniquePtr_V< volatile TUniquePtr< T, Deleter > >  
Public variable bool TIsTuple_V  
Public variable bool TIsTuple_V< const TTuple< Types... > >  
Public variable bool TIsTuple_V< const volatile TTuple< Types... > >  
Public variable bool TIsTuple_V< TTuple< Types... > >  
Public variable bool TIsTuple_V< volatile TTuple< Types... > >  
Public variable bool TIsTWeakPtr_V Trait which determines whether or not a type is a TWeakPtr.
Public variable bool TIsTWeakPtr_V< const TWeakPtr< ObjectType, InMode > >  
Public variable bool TIsTWeakPtr_V< const volatile TWeakPtr< ObjectType, InMode > >  
Public variable bool TIsTWeakPtr_V< TWeakPtr< ObjectType, InMode > >  
Public variable bool TIsTWeakPtr_V< volatile TWeakPtr< ObjectType, InMode > >  
Public variable bool TModels_V Trait which does concept checking.
Public variable uint32 TTypeCountInParameterPack_V  
Public variable uint32 TTypeCountInParameterPack_V< T, U, Types... >  

Ask questions and help your peers Developer Forums

Write your own tutorials or read those from others Learning Library

On this page