Class Hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:

[detail level 12345]

CMcroBuild.AbsolutePathExtensions	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
►CBaseTypes...
CMcro::Inheritance::TInherit< BaseTypes >	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
►Cstd::conditional_t
CMcro::Range::TExtendedIterator< Iterator, Policy >	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
CMcro::Ansi::FAllocator	Allocator that allocates memory using standard library functions
CMcro::Any::FAny	A simplistic but type-safe and RAII compliant storage for anything. Enclosed data is owned by this type
CMcro::UObjects::Init::FConstructObjectParameters	Mirror of FStaticConstructObjectParameters but it's a plain C++ object and doesn't have a constructor so designated initialization with named members is possible
CFCopyConstructCounter
CMcro::Error::FDisplayErrorArgs	Control how an error is being displayed. Use C++ 20 designated initializers for convenience
CMcro::Error::FErrorManager	Global facilities for IError handling, including displaying them to the user, trigger error events, etc
CMcro::Delegates::FEventPolicy	Settings for the TEventDelegate class, which defines optional behavior when adding a binding to it
CMcro::Range::FExtendedIteratorPolicy	Extra settings for TExtendedIterator wrapper
CMcro::Finally::FFinallySyntaxSupport
CMcro::Text::Macros::FInvTextFakeLiteralTag
CFMapPairsAccessTag
CMcro::Text::Macros::FNameFakeLiteralTag
►CFNoncopyable
CFCopyForbidden
CMcro::Finally::FFinally	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
CMcro::Modules::TModuleBoundObject< M, T >::FObjectFactory
CMcro::Modules::FObserveModuleListener	A record for the module event listeners
CMcro::Once::FOnce	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
►CMcro::Ansi::FAllocator::ForAnyElementType
CMcro::Ansi::FAllocator::ForElementType< ElementType >
CMcro::Range::FRangeStringFormatOptions
CMcro::Dll::FScopedDll	RAII wrapper around GetDllHandle / FreeDllHandle
CMcro::Dll::FScopedDllSet	Handle multiple DLL files in one set and an optional base path for them
CMcro::Dll::FScopedSearchPath	RAII wrapper around PushDllDirectory / PopDllDirectory
CMcro::Observable::FStatePolicy	Flags expressing how TState should handle object comparison and lifespan
CMcro::Text::Macros::FStdStringLiteralTag
CMcro::Text::Macros::FStringFakeLiteralTag
CMcro::Text::Macros::FStringViewFakeLiteralTag
CMcro::TypeInfo::FType	Group together type info for identification. Can have an invalid state when no type is specified
CMcro::ValueThunk::FValueThunkOptions	Options for value thunks
CFVoid	This struct may be used for situations where something needs to be returned but it's not meaningful to do so
CMcro::Zero::FZero	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
►CMcro::AutoModularFeature::IAutoModularFeature	Tagging an auto feature (DO NOT USE MANUALLY, inherited by TAutoModularFeature)
►CMcro::AutoModularFeature::TAutoModularFeature< IErrorDisplayExtension >
CMcro::Error::IErrorDisplayExtension	A modular feature which allows other modules to inject their own UI into the common error display widget
►CMcro::AutoModularFeature::TAutoModularFeature< IErrorWindowExtension >
CMcro::Error::IErrorWindowExtension	A modular feature which allows other modules to inject their own UI into error windows displayed to the user
CMcro::AutoModularFeature::TAutoModularFeature< FeatureIn >	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
►CMcro::Composition::IComponent	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
CMcro::Composition::IStrictComponent	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
CMcro::Composition::IComposable	A base class which can bring type based class-composition to a derived class
CMcro::AutoModularFeature::IFeatureImplementation	Tagging an implementation of a feature
►CIFormattable
CMcroBuild.AbsolutePath	A simplified copy of NUKE's own AbsolutePath class https://github.com/nuke-build/nuke/blob/develop/source/Nuke.Utilities/IO/AbsolutePath.cs
►CMcro::Types::IHaveType	A barebones base class for types which may store their type-name as a string
►CMcro::Types::IHaveTypeShareable	Shorthand for combination of IHaveType and TSharedFromThis
►CMcro::Error::IError	A base class for a structured error handling and reporting with modular architecture and fluent API
CMcro::Error::FAssertion	A simple error type for checking booleans. It adds no extra features to IError
►CMcro::Error::FCppException	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
CMcro::Error::TCppException< Exception >	Use this template for catching STL exceptions to preserve the exception type name
CMcro::Error::FUnavailable	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
►CMcro::Error::IPlainTextComponent	An error component which displays only its Message, used as simple modular plain text storage
CMcro::Error::FBlueprintStackTrace	An Error component which stores a BP stack trace in its message upon construction
CMcro::Error::FCppStackTrace	An Error component which stores a C++ stack trace in its message upon construction
CMcro::Windows::Error::FHresultError	An error wrapping HRESULT code returned by many Microsoft APIs. It will also collect human readable metadata
CMcro::Windows::Error::FLastError	An error wrapping the returned code of GetLastError and attempts to get a string description of it
CMcro::Types::THasTypeShareable< T >	Shorthand for combination of IHaveType and TSharedFromThis where the base-type can be specified
►CIModularFeature
CMcro::AutoModularFeature::TAutoModularFeature< IErrorDisplayExtension >
CMcro::AutoModularFeature::TAutoModularFeature< IErrorWindowExtension >
CMcro::AutoModularFeature::TAutoModularFeature< FeatureIn >	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
►CIModuleInterface
CMcro::Modules::IObservableModule	Add this interface to your module class if other things can listen to module startup or shutdown
►CMcro::Observable::IStateTag
►CMcro::Observable::IState< T >	Public API and base class for TState which shouldn't concern with policy flags or thread safety
CMcro::Observable::TState< T, DefaultPolicy >	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
CMcroBuild.ModuleRuleExtensions	Convenience utilities for module rules
►CModuleRules
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
CMcro::Range::OutputTo< Target >	Render a range to an already existing container
CMcro::Range::OutputToMap< Target >	Output a range of tuples or range of ranges with at least 2 elements to an already existing TMap
CMcro::Templates::TTemplate< Template >::Parameters< T >
CMcro::Templates::TTemplate< Template >::Parameters< Template< Params... > >
CMcro::Templates::TTemplate< Template >::ParametersDecay< T >
CMcro::Templates::TTemplate< Template >::ParametersDecay< Template< Params... > >
CMcroBuild.PathUtils	Support utilities for AbsolutePath
►Cstd::random_access_iterator_tag
CMcro::Range::FTempStringIterator	Allows range-v3 and std::ranges to iterate over temporary string objects and keep the string alive during view and action operators
CMcro::Range::RenderAs< Target >	Render a range as the given container
CMcro::Range::RenderAsMap	Render a range of tuples or range of ranges with at least 2 elements as a TMap
CMcroBuild.RuntimeDependencies	Model for reading a collection of runtime dependencies gathered by an external tool into an XML document
CMcroBuild.RuntimeDependency	Model for one runtime dependency
►CSCompoundWidget
►CMcro::Error::SErrorDisplay	Base class for displaying Mcro::Error::IError objects to the user
CMcro::Error::SPlainTextDisplay	Displaying error components which just provide a block of text (like a stack-trace)
CMcro::Slate::Detail::TReactiveWidgetBase< Item, Range, ContainerWidget, ChildWidget, ChildrenRange, IndexType >
►CTAllocatorTraitsBase
CTAllocatorTraits< Mcro::Ansi::FAllocator >
CMcro::Any::TAnyTypeFacilities< T >	Give the opportunity to customize object lifespan operations for FAny by either specializing this template or just providing functors in-place
CMcro::Slate::TArgumentsOf_Struct< T >
CMcro::Slate::TArgumentsOf_Struct< T >
CMcro::Text::TAsFormatArgument< T >
CMcro::Text::TAsFormatArgument< FStdStringView >
CMcro::Text::TAsFormatArgument< Operand >	Convert Unreal/STL/Range-V3 tuples to string the following way: (Item0, Item1, Item2, ...)
CMcro::Text::TAsFormatArgument< TStdString< CharType > >
CMcro::Slate::TAttributeBlockFunctor< T >	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
CMcro::Badge::TBadge< T >	Use this template to give exclusive access to functions to specific classes
CMcro::Observable::TChangeData< T >	This struct holds the circumstances of the data change. It cannot be moved or copied and its lifespan is managed entirely by TState
CMcro::FunctionTraits::TDeferFunctionArguments< FuncPtr, Function >	Defers a set of arguments for a function call later with its first argument. This is useful for developing fluent API operators
►CMcro::FunctionTraits::TDeferFunctionArguments<&AsLocalizable_Advanced >
CMcro::Text::Macros::FDefer_AsLocalizable_Advanced
CMcro::Delegates::TDynamicMethodPtr_Struct< typename >
CMcro::Delegates::TDynamicMethodPtr_Struct< Dynamic >
CMcro::Delegates::TDynamicSignature_Struct< typename >
CMcro::Delegates::TDynamicSignature_Struct< Dynamic >
CMcro::Delegates::TEventDelegate< Function, DefaultPolicy >	"Extension" of a common TMulticastDelegate. It allows to define optional "flags" when adding a binding, in order to:
CMcro::Delegates::TEventDelegate< void()>
CMcro::Delegates::TEventDelegate< void(Args...), DefaultPolicy >	"Extension" of a common TMulticastDelegate. It allows to define optional "flags" when adding a binding, in order to:
CMcro::Delegates::TEventDelegate< void(Mcro::Observable::TChangeData< T > const &)>
CMcro::Concepts::Detail::TExtractClassName< T >
CMcro::Concepts::Detail::TExtractClassName< MemberType ClassType::* >
CMcro::FunctionTraits::Detail::TFunctionFromTuple_Struct< Return, Tuple >
CMcro::FunctionTraits::Detail::TFunctionMeta< ReturnIn, Args >
►CMcro::FunctionTraits::Detail::TFunctionMeta< ReturnIn, Args... >
CMcro::FunctionTraits::TFunctionTraits< ReturnIn(*)(Args...)>	Specialization extracting the types from the compound function pointer type
CMcro::FunctionTraits::TFunctionTraits< ReturnIn(Args...)>	Specialization extracting the types from the compound function type
CMcro::FunctionTraits::TFunctionTraits< ReturnIn(ClassIn::*)(Args...) const >	Specialization extracting the types from the compound function pointer type of a const member function
CMcro::FunctionTraits::TFunctionTraits< ReturnIn(ClassIn::*)(Args...)>	Specialization extracting the types from the compound function pointer type of a member function
CMcro::FunctionTraits::TFunctionTraits< T >	Get signature information about any function declaring type (function pointer or functor structs including lambda functions). It should be used in other templates
►CMcro::FunctionTraits::TFunctionTraits< decltype(&std::decay_t< T >::operator())>
CMcro::FunctionTraits::TFunctionTraits< T >	Specialization for functor structs / lambda functions
CMcro::InitializeOnCopy::TInitializeOnCopy< T >	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
CMcro::InitializeOnCopy::TInitializeOnCopy< FCriticalSection >
CMcro::InitializeOnCopy::TInitializeOnCopy< FRWLock >
CMcro::Templates::TIsTypeList_Struct< T >
CMcro::Templates::TIsTypeList_Struct< TTypes< T... > >
►CTIteratorCategory
CMcro::Range::TExtendedIterator< Iterator, Policy >	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
CMcro::Range::TIteratorCompare_Struct< T >
CMcro::Range::TIteratorCompare_Struct< T >
CMcro::Range::TIteratorComputeDistance_Struct< T >
CMcro::Range::TIteratorComputeDistance_Struct< T >
CMcro::Range::TIteratorDifference_Struct< T >
CMcro::Range::TIteratorDifference_Struct< T >
CMcro::Range::TIteratorJumpBackward_Struct< T >
CMcro::Range::TIteratorJumpBackward_Struct< T >
CMcro::Range::TIteratorJumpForward_Struct< T >
CMcro::Range::TIteratorJumpForward_Struct< T >
CTMapBase< FMapPairsAccessTag, FMapPairsAccessTag, FMapPairsAccessTag, FMapPairsAccessTag >
CMcro::Error::TMaybe< T >	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
CMcro::Modules::TModuleBoundObject< M, T >	A wrapper around a given object which lifespan is bound to given module
►CMcro::Modules::TModuleBoundObject< M, FScopedDllSet >
CMcro::Dll::TModuleBoundDlls< M >	List DLL's which is used by a specific module and its owning plugin
CMcro::Delegates::TNative_Struct< typename >
CMcro::Delegates::TNative_Struct< Dynamic >
CMcro::Delegates::TNativeEvent_Struct< Dynamic, DefaultPolicy >	Map the input dynamic multicast delegate to a conceptually compatible native event delegate type
CMcro::Modules::TObserveModule< M >	Use this in global variables to automatically do things on module startup or shutdown
CMcro::Range::Detail::TRangeWithStringFormat< Range >
►CDetail::TReactiveWidgetBase< Item, TArray< Item >, SWidget, SWidget, TArray< TSharedRef< SWidget > >, int32 >
CMcro::Slate::TArrayReactiveWidget< Item, ContainerWidget, ChildWidget, Base >	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
►CDetail::TReactiveWidgetBase< Item, TMap< Key, Item >, SWidget, SWidget, TMap< Key, TSharedRef< SWidget > >, Key >
CMcro::Slate::TMapReactiveWidget< Key, Item, ContainerWidget, ChildWidget, Base >	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
CMcro::Yaml::TScopedRegion< Begin, End >	RAII friendly region annotation for YAML::Emitter streams
CMcro::UObjects::Init::TScopeObject< T >	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
►CTSetAllocator
CMcro::Ansi::FSetAllocator	Allocator for sets to follow standard allocation behavior
►CTSharedFromThis
CMcro::Types::IHaveTypeShareable	Shorthand for combination of IHaveType and TSharedFromThis
CMcro::Types::THasTypeShareable< T >	Shorthand for combination of IHaveType and TSharedFromThis where the base-type can be specified
CMcro::SharedObjects::TSharedStorage< T >	A simple mutable shared storage of any value
CMcro::Tuples::TSkip_Struct< Count, Tuple >
CMcro::Slate::TSlots< Range, Transform, OnEmpty, CSlotArguments >	Add multiple slots at the same time with the declarative syntax derived from an input data array
CMcro::TypeInfo::FType::TTag< T >
CMcro::Tuples::TTake_Struct< Count, Tuple >
CMcro::Templates::TTemplate< Template >	Base struct containing traits of specified template (which only accepts type parameters)
CMcro::Rendering::Textures::TTextureSize< SizeType, InFormatType >	A simple texture size description which can be used for checking the need to recreate a texture resource
CMcro::Tuples::TTrimEnd_Struct< Count, Tuple >
CMcro::Templates::TTupleSafeElement_Struct< I, T >
CMcro::Templates::TTupleSafeElement_Struct< I, TTuple< T... > >
CMcro::Tuples::TTypeAt_Struct< size_t, typename >
CMcro::Tuples::TTypeAt_Struct< I, T >
CMcro::Templates::Detail::TTypeAtPack_Impl< I, First, Rest >
CMcro::Templates::Detail::TTypeAtPack_Impl< 0, First, Rest... >
CMcro::Templates::TTypeAtPack_Struct< I, T >
CMcro::Templates::TTypeAtPack_Struct< I >
CMcro::Templates::TTypes< T >	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
CMcro::ValueThunk::TValueThunk< T >	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
►CUObject
CUDynamicDelegateTestClass