| ▼NMcro | |
| ►NAnsi | Epic Games may not agree with standards because they know better, but sometimes we have to bare consequences of such wisdom. This namespace contains utilities which politely circumvent the obviously superior decisions Epic Games has made |
| ►CFAllocator | Allocator that allocates memory using standard library functions |
| CForAnyElementType | |
| CForElementType | |
| CFSetAllocator | Allocator for sets to follow standard allocation behavior |
| ►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 |
| ►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 template 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 |
| CTModuleBoundDlls | List DLL's which is used by a specific module and its owning plugin |
| ►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 | |
| CTFunctionFromTypes_Struct | |
| CTFunctionFromTypes_Struct< Return, TTypes< Types... > > | |
| 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 |
| ►NInheritance | |
| 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 |
| ►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 |
| CFObserveModuleListener | A record for the module event listeners |
| CIObservableModule | Add this interface to your module class if other things can listen to module startup or shutdown |
| ►CTModuleBoundObject | A wrapper around a given object which lifespan is bound to given module |
| CFObjectFactory | |
| 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 FStatePolicy::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 | Restore range-v3 compatibility for TArray on UE 5.8+ |
| ►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 |
| ►NDetail | |
| CTReactiveWidgetBase | |
| CTArgumentsOf_Struct | |
| CTArgumentsOf_Struct< T > | |
| CTArrayReactiveWidget | A widget template which can automatically handle changes in an input array state, with given delegates which tell this widget how children are supposed to be created, updated and removed |
| 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 |
| CTMapReactiveWidget | A widget template which can automatically handle changes in an input map state, with given delegates which tell this widget how children are supposed to be created, updated and removed |
| CTSlots | Add multiple slots at the same time with the declarative syntax derived from an input data array |
| ►NTemplates | This namespace provides templating utilities and introspection into template instantiations |
| ►NDetail | |
| CTTypeAtPack_Impl | |
| CTTypeAtPack_Impl< 0, First, Rest... > | |
| CTIsTypeList_Struct | |
| CTIsTypeList_Struct< TTypes< T... > > | |
| CTTemplate_Match | Base struct for matching templates disregarding their arguments |
| CTTemplate_Struct | |
| CTTemplate_Struct< Template< Params... > > | Base struct containing traits of specified template instance (which only accepts type parameters) |
| CTTemplateMap_Struct | |
| CTTemplateMap_Struct< TemplateOut, TemplateIn< Params... > > | |
| CTTupleSafeElement_Struct | |
| CTTupleSafeElement_Struct< I, TTuple< T... > > | |
| CTTypeAtPack_Struct | |
| CTTypeAtPack_Struct< I > | |
| CTTypes | This template is used to store pack of types in other templates, or to allow parameter pack inference for functions. This template may be referred to as 'type-list' in other parts of the documentation |
| CTTypesSkip_Struct | |
| CTTypesTake_Struct | |
| CTTypesTrimEnd_Struct | |
| ►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 | |
| 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 |
| CTTupleSkip_Struct | |
| CTTupleTake_Struct | |
| CTTupleTrimEnd_Struct | |
| CTTypeAt_Struct | |
| CTTypeAt_Struct< I, T > | |
| ►NTypeInfo | |
| ►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 |
| CIHaveTypeShareable | Shorthand for combination of IHaveType and TSharedFromThis |
| CTHasTypeShareable | Shorthand for combination of IHaveType and TSharedFromThis where the base-type can be specified |
| ►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 |
| ►NValueThunk | |
| CFValueThunkOptions | Options for value thunks |
| CTValueThunk | Either a singular value of T, or a function returning T. It's very similar to TAttribute, however it doesn't rely on delegates, and has implicit conversions. TValueThunk owns its wrapped value |
| ►NWindows | |
| ►NError | |
| CFHresultError | An error wrapping HRESULT code returned by many Microsoft APIs. It will also collect human readable metadata |
| CFLastError | An error wrapping the returned code of GetLastError and attempts to get a string description of it |
| ►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 |
| ▼NMcroBuild | |
| CAbsolutePath | A simplified copy of NUKE's own AbsolutePath class https://github.com/nuke-build/nuke/blob/develop/source/Nuke.Utilities/IO/AbsolutePath.cs |
| CAbsolutePathExtensions | The API NUKE has for AbsolutePath relies heavily on extension methods. In fact if file system operations are expressed with extension methods to AbsolutePath it can yield code which is much more comfortable to write |
| CModuleRuleExtensions | Convenience utilities for module rules |
| CPathUtils | Support utilities for AbsolutePath |
| CRuntimeDependencies | Model for reading a collection of runtime dependencies gathered by an external tool into an XML document |
| CRuntimeDependency | Model for one runtime dependency |
| 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 |
| CMcro | Low level C++ (mostly) templating utilities for a variety of common problems occuring during Unreal Development |
| CMcroISPC | A module containing ISPC utilities |
| CMcroWindows | A module containing Windows platform specific utilities like interop between Unreal and WinRT/COM |
| CTAllocatorTraits< Mcro::Ansi::FAllocator > | |
| CTMapBase< FMapPairsAccessTag, FMapPairsAccessTag, FMapPairsAccessTag, FMapPairsAccessTag > | |
| CUDynamicDelegateTestClass | |
1.12.0