Data Structures

Here are the data structures with brief descriptions:

[detail level 1234]

▼NMcro
►NAny
CFAny	A simplistic but type-safe and RAII compliant storage for anything. Enclosed data is owned by this type
CTAnyTypeFacilities	Give the opportunity to customize object lifespan operations for FAny by either specializing this template or just providing functors in-place
CTInherit	Inherit via this template to allow other API to reflect upon the base types of deriving class. Base types are inherited as public. If you want privately inherited base classes, just inherit them as normal
CTTypes	This template is used in IComponent|FAny::With(TAlias<...>) so it can have deduced this type and explicit variadic template arguments when specifying multiple aliases
►NAutoModularFeature
CIAutoModularFeature	Tagging an auto feature (DO NOT USE MANUALLY, inherited by TAutoModularFeature)
CIFeatureImplementation	Tagging an implementation of a feature
CTAutoModularFeature	Auto Modular Features are a workflow with Modular Features where the developer doesn't have to rely on string identifiers. TAutoModularFeature and TFeatureImplementation templates take care of naming the feature and introduces some common functionality, like getter functions and runtime validations
►NBadge
CTBadge	Use this template to give exclusive access to functions to specific classes
►NComposition	Namespace containing utilities and base classes for type composition
CIComponent	Inherit from this empty interface to signal that the inheriting class knows that it's a component and that it can receive info about the composable class it is being registered to
CIComposable	A base class which can bring type based class-composition to a derived class
CIStrictComponent	Inherit from this empty interface to signal that the inheriting class knows that it's a component and that it can receive info about the composable class it is being registered to
►NConcepts
►NDetail
CTExtractClassName
CTExtractClassName< MemberType ClassType::* >
►NDelegates
CFEventPolicy	Settings for the TEventDelegate class, which defines optional behavior when adding a binding to it
CTDynamicMethodPtr_Struct
CTDynamicMethodPtr_Struct< Dynamic >
CTDynamicSignature_Struct
CTDynamicSignature_Struct< Dynamic >
CTEventDelegate	"Extension" of a common TMulticastDelegate. It allows to define optional "flags" when adding a binding, in order to:
CTEventDelegate< void(Args...), DefaultPolicy >	"Extension" of a common TMulticastDelegate. It allows to define optional "flags" when adding a binding, in order to:
CTNative_Struct
CTNative_Struct< Dynamic >
CTNativeEvent_Struct	Map the input dynamic multicast delegate to a conceptually compatible native event delegate type
►NDll
CFScopedDll	RAII wrapper around GetDllHandle / FreeDllHandle
CFScopedDllSet	Handle multiple DLL files in one set and an optional base path for them
CFScopedSearchPath	RAII wrapper around PushDllDirectory / PopDllDirectory
►NError	Contains utilities for structured error handling
CFAssertion	A simple error type for checking booleans. It adds no extra features to IError
CFBlueprintStackTrace	An Error component which stores a BP stack trace in its message upon construction
CFCppException	Unreal itself discourages the usage of C++ exceptions and there are also couple of thoughts above IError why that's the case. However, there are third-party libraries which may require their users to catch errors, their functions may, yield via exceptions. For this reason there's an IError wrapper around std::exception base class which however will not preserve the actual type of the caught exception. For that use TCppException template
CFCppStackTrace	An Error component which stores a C++ stack trace in its message upon construction
CFDisplayErrorArgs	Control how an error is being displayed. Use C++ 20 designated initializers for convenience
CFErrorManager	Global facilities for IError handling, including displaying them to the user, trigger error events, etc
CFUnavailable	A simple error type denoting that whatever is being accessed is not available like attempting to access nullptr. It adds no extra features to IError
CIError	A base class for a structured error handling and reporting with modular architecture and fluent API
CIErrorDisplayExtension	A modular feature which allows other modules to inject their own UI into the common error display widget
CIErrorWindowExtension	A modular feature which allows other modules to inject their own UI into error windows displayed to the user
CIPlainTextComponent	An error component which displays only its Message, used as simple modular plain text storage
CSErrorDisplay	Base class for displaying Mcro::Error::IError objects to the user
CSPlainTextDisplay	Displaying error components which just provide a block of text (like a stack-trace)
CTCppException	Use this template for catching STL exceptions to preserve the exception type name
CTMaybe	A TValueOrError alternative for IError which allows implicit conversion from values and errors (no need for MakeError or MakeValue) and is boolean testable. It also doesn't have ambiguous state such as TValueOrError has, so a TMaybe will always have either an error or a value, it will never have neither of them or both of them
►NFinally
CFFinally	Run arbitrary finalizers on destruction. It has similar purpose to ON_SCOPE_EXIT, however FFinally can be moved around into different scopes, Payload will be only executed if the finalizer hasn't been moved from, otherwise the payload will be ignored in the source of move assignments
CFFinallySyntaxSupport
►NFunctionTraits
►NDetail
CTFunctionFromTuple_Struct
CTFunctionMeta
CTDeferFunctionArguments	Defers a set of arguments for a function call later with its first argument. This is useful for developing fluent API operators
CTFunctionTraits	Get signature information about any function declaring type (function pointer or functor structs including lambda functions). It should be used in other templates
CTFunctionTraits< ReturnIn(*)(Args...)>	Specialization extracting the types from the compound function pointer type
CTFunctionTraits< ReturnIn(Args...)>	Specialization extracting the types from the compound function type
CTFunctionTraits< ReturnIn(ClassIn::*)(Args...) const >	Specialization extracting the types from the compound function pointer type of a const member function
CTFunctionTraits< ReturnIn(ClassIn::*)(Args...)>	Specialization extracting the types from the compound function pointer type of a member function
CTFunctionTraits< T >	Specialization for functor structs / lambda functions
►NInitializeOnCopy
CTInitializeOnCopy	A type wrapper around a default initializeable object which may not be copyable but which needs to be a member of a copyable class. On each instance of such class the wrapped value may not need to be copied and default constructing it is enough. Useful for mutexes for example
►NModules	Namespace for utilities handling Unreal modules
CIObservableModule	Add this interface to your module class if other things can listen to module startup or shutdown
CTObserveModule	Use this in global variables to automatically do things on module startup or shutdown
►NObservable
CFStatePolicy	Flags expressing how TState should handle object comparison and lifespan
CIState	Public API and base class for TState which shouldn't concern with policy flags or thread safety
CIStateTag
CTChangeData	This struct holds the circumstances of the data change. It cannot be moved or copied and its lifespan is managed entirely by TState
CTState	Storage wrapper for any value which state needs to be tracked or their change needs to be observed. By default, TState is not thread-safe unless EStatePolicy::ThreadSafe policy is active in DefaultPolicy
►NOnce
CFOnce	Used for lambdas which supposed to run only once. The first time it is converted to bool it returns true but every other times it will return false
►NRange
►NDetail
CTRangeWithStringFormat
CFExtendedIteratorPolicy	Extra settings for TExtendedIterator wrapper
CFRangeStringFormatOptions
CFTempStringIterator	Allows range-v3 and std::ranges to iterate over temporary string objects and keep the string alive during view and action operators
COutputTo	Render a range to an already existing container
COutputToMap	Output a range of tuples or range of ranges with at least 2 elements to an already existing TMap
CRenderAs	Render a range as the given container
CRenderAsMap	Render a range of tuples or range of ranges with at least 2 elements as a TMap
CTExtendedIterator	Unreal's own iterators are not STL compliant (they are only compatible with range-for loops) so they cannot be used with more advanced STL algorithms or other third-party libraries which may expect the full iterator interface compatibility. For that TExtendedIterator fills in the missing components and wraps Unreal iterators to be fully STL iterator compliant
CTIteratorCompare_Struct
CTIteratorCompare_Struct< T >
CTIteratorComputeDistance_Struct
CTIteratorComputeDistance_Struct< T >
CTIteratorDifference_Struct
CTIteratorDifference_Struct< T >
CTIteratorJumpBackward_Struct
CTIteratorJumpBackward_Struct< T >
CTIteratorJumpForward_Struct
CTIteratorJumpForward_Struct< T >
►NRendering
►NTextures	This namespace contain utilities regarding high-level cross-platform and cross-rhi texture objects
CTTextureSize	A simple texture size description which can be used for checking the need to recreate a texture resource
►NSharedObjects	Utilities for TSharedPtr/Ref and related
CTSharedStorage	A simple mutable shared storage of any value
►NSlate	Extra functionalities for general Slate programming chores, including enhancements of the Slate declarative syntax
CTArgumentsOf_S
CTArgumentsOf_S< T >
CTAttributeBlockFunctor	An attribute block functor which takes in reference of FArguments or FSlotArguments and returns the same reference but presumably setting some Slate attributes before that. This is useful for modularizing the Slate declarative syntax
CTSlots	Add multiple slots at the same time with the declarative syntax derived from an input data array
►NTemplates	This namespace provide some introspection into template instantiations
►CTTemplate	Base struct containing traits of specified template (which only accepts type parameters)
CParameters
CParameters< Template< Params... > >
CParametersDecay
CParametersDecay< Template< Params... > >
►NText	Mixed text utilities and type traits
►NMacros	This namespace is used by MCRO text literal macros, don't use it directly!
CFDefer_AsLocalizable_Advanced
CFInvTextFakeLiteralTag
CFNameFakeLiteralTag
CFStdStringLiteralTag
CFStringFakeLiteralTag
CFStringViewFakeLiteralTag
CTStringPrintfLiteral
CTAsFormatArgument
CTAsFormatArgument< FStdStringView >
CTAsFormatArgument< Operand >	Convert Unreal/STL/Range-V3 tuples to string the following way: (Item0, Item1, Item2, ...)
CTAsFormatArgument< TStdString< CharType > >
►NTuples	Templating utilities for manipulating TTuples
CTSkip_Struct
CTTake_Struct
CTTrimEnd_Struct
CTTypeAt_Struct
CTTypeAt_Struct< I, T >
►NTypeName
►CFType	Group together type info for identification. Can have an invalid state when no type is specified
CTTag
►NTypes	C++ native static reflection utilities, not to be confused with reflection of UObjects
CIHaveType	A barebones base class for types which may store their type-name as a string
►NUObjects
►NInit
CFConstructObjectParameters	Mirror of FStaticConstructObjectParameters but it's a plain C++ object and doesn't have a constructor so designated initialization with named members is possible
CTScopeObject	A struct to emulate regular C++ RAII object behavior with UObjects. When this struct is instantiated the given object type is also created. An object wrapped in this struct is never invalid, and doesn't get garbage collected until it's in scope
►NYaml
CTScopedRegion	RAII friendly region annotation for YAML::Emitter streams
►NZero
CFZero	A type which acts like a number, but it always returns another FZero for any operations and converting it to any scalar type yields 0. So if an FZero is found in a chain of operation the result will be always 0
CFCopyConstructCounter
CFCopyForbidden
CFMapPairsAccessTag
CFVoid	This struct may be used for situations where something needs to be returned but it's not meaningful to do so
CTMapBase< FMapPairsAccessTag, FMapPairsAccessTag, FMapPairsAccessTag, FMapPairsAccessTag >
CUDynamicDelegateTestClass