Templates

Deletes an object via the standard delete operator

Euclidean algorithm using modulo policy.

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

Wrapper for a type that yields a reference to that type.

Utility template for a class that should not be copyable.

Used to avoid cluttering code with ifdefs.

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

Float cast to uint32 which maintains sorted order http://codercorner.com/RadixSortRevisited.htm

Base class implementing thread-safe reference counting.

The base class of reference counted objects.

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

Dummy structures used internally as template arguments for typecasts

Like FRefCountedObject, but internal ref count is thread safe

Forward declarations.

Helper classes to help debugger visualization.

Common interface to a callable object owned by TFunction.

Common interface to a callable object owned by TFunction.

Common interface to a callable object owned by TFunction.

A virtual interface for ref counted objects to implement.

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

Used to declare an untyped array of data with compile-time alignment.

Does a boolean AND of the Value static members of each type, but short-circuits if any Type::Value == false.

Wraps a range into a container like interface to satisfy the GetData and GetNum global functions.

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

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

Integral atomic implementation - allows arithmetic and bitwise operations.

TODO : basic storage and getting and setting, but the element is protected by a mutex instead of using platform atomics.

Pointer atomic implementation - allows arithmetic with PTRINT.

Base class for call traits. Used to more easily refine portions when specializing

Call traits helpers

Chooses between two different classes based on a boolean.

Copies the cv-qualifiers and references from one type to another, e.g.:

Copies the cv-qualifiers from one type to another, e.g.:

Single-ownership smart pointer in the vein of std::unique_ptr.

A helper class that efficiently stores a custom deleter and is intended to be derived from.

Helper class for dereferencing pointer types in Sort function

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.

Includes a function in an overload set if the predicate is true.

Binary predicate class for performing equality comparisons.

Template for initializing a singleton at the boot.

TFormatSpecifier, only applies to numeric types

Implementation of IFunction_OwnedObject for a given copyable T.

Implementation of IFunction_OwnedObject for a given non-copyable T.

A class which defines an operator() which will own storage of a callable and invoke the TFunctionRefCaller::Call function on it.

A class which is used to instantiate the code needed to call a bound function.

Binary predicate class for sorting elements in reverse order.

Exception-safe guard around saving/restoring a value.

Defines a value metafunction of the given Value.

Trait for the type of the result when invoking a callable with the given argument types.

Traits class which tests if a type is abstract.

Traits class which tests if a type is arithmetic.

Traits class which tests if a type is a C++ array.

Type trait which returns true if the type T is an array or a reference to an array of ArrType.

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.

Tests if a type T is bitwise-constructible from a given argument type U.

Traits class which tests if a type is a bounded C++ array.

Determines if T is a struct/class type

Traits class which tests if a type is const.

Determines if T is constructible from a set of arguments.

Is type DerivedType inherited from BaseType.

Traits class which tests if a type is arithmetic.

Traits class which tests if a type is floating point.

TIsFunction

Tests is a type is a function.

TIsFundamentalType

Traits class which tests if a type is an initializer list.

Traits class which tests if a type is integral.

Traits class which tests if an instance of CallableType can be invoked with a list of the arguments of the types provided.

TIsLValueReferenceType

Traits class which tests if a type is a pointer to member (data member or member function).

Traits class which tests if a type is a pointer.

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

TIsReferenceType

TIsRValueReferenceType

Traits class which tests if a type is a signed integral type.

Traits class which checks if T is a TFunction<> type.

Traits class which checks if T is a TFunctionRef<> type.

Traits class which tests if a type is trivial.

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

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

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

Traits class which checks if T is a TFunction<> type.

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

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

Traits class which tests if a type is an unbounded C++ array.

Tests if a type is a valid argument to a variadic function, e.g. printf.

Array rotation using juggling technique.

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

This is a variant of the above that will determine the return type 'lazily', i.e. only if the function is enabled.

Binary predicate class for sorting elements in order.

Tests if qualifiers are lost between one type and another, e.g.:

Traits class which gets the signed version of an integer type.

Traits class which gets the unsigned version of an integer type.

Finds the maximum sizeof the supplied types

Merge sort class.

Utilities for concepts checks.

TNameOf

TNonNullPtr is a non-nullable, non-owning, raw/naked/unsafe pointer.

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

TIsSame

Does a boolean OR of the Value static members of each type, but short-circuits if any Type::Value == true.

Forward declaration.

Version of [TPointerIsConvertibleFromTo](API\Runtime\Core\Templates\TPointerIsConvertibleFromTo_1)_ that produces an incomplete type when either From or `To are incomplete types

Tests if a From* is convertible to a To*

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

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

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

TRemoveCV will remove any const/volatile qualifiers from a type.

Removes one dimension of extents from an array type.

Removes one level of pointer from a type, e.g.:

TRemoveReference will remove any references from a type.

TRetainedRef

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

Merge policy for merge sort.

TRotationPolicy Policy for array rotation algorithm.

TRValueToLValueReference converts any rvalue reference type into the equivalent lvalue reference, otherwise returns the same type.

Commonly used to make sure a value is incremented, and then decremented anyway the function can terminate.

Helper object for batching callback requests and firing on destruction of the FScopedCallback object.

Derive your class from TSharedFromThis to enable access to a TSharedRef directly from an object instance that's already been allocated.

TSharedPtr is a non-intrusive reference-counted authoritative object pointer.

NOTE: TSharedRef is an Unreal extension to standard smart pointer feature set.

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

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

Traits for types.

Helper for array traits.

TUniqueFunction

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

A traits class which specifies whether a Swap of a given type should swap the bits or use a traditional value-based swap.

TWeakPtr is a non-intrusive reference-counted weak object pointer.

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

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

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

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

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

Creates a custom reference controller with a specified deleter

Creates a reference controller which just calls delete

Creates an intrusive reference controller

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.

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