ModuleBoilerplate.h File Reference

#include "CoreTypes.h"
#include "HAL/UnrealMemory.h"
#include "UObject/NameTypes.h"
#include "HAL/Memory.h"
#include "Modules/VisualizerDebuggingState.h"

Go to the source code of this file.

Macros
#define	PER_MODULE_BOILERPLATE_ANYLINK(ModuleImplClass, ModuleName)
#define	OPERATOR_NEW_MSVC_PRAGMA
#define	UE_DEFINE_FMEMORY_WRAPPERS
#define	REPLACEMENT_OPERATOR_NEW_AND_DELETE
#define	UE_VISUALIZER_USE_AND_RETAIN
#define	UE_ENABLE_VISUALIZER_HELPERS   1
#define	UE_VISUALIZERS_HELPERS
#define	PER_MODULE_BOILERPLATE

Macro Definition Documentation

OPERATOR_NEW_MSVC_PRAGMA

#define OPERATOR_NEW_MSVC_PRAGMA

Override new + delete operators (and array versions) in every module. This prevents the possibility of mismatched new/delete calls such as a new[] that uses Unreal's allocator and a delete[] that uses the system allocator.

Overloads have to guarantee at least 1 byte is allocated because otherwise new T[0] could return a null pointer, as could ::operator new(0), depending on the allocator (e.g. TBB), which is non-standard behaviour.

FMemory_Malloc, FMemory_Realloc and FMemory_Free have been added for thirdparty libraries that need malloc. These functions will allow for proper memory tracking.

PER_MODULE_BOILERPLATE

#define PER_MODULE_BOILERPLATE

Value:

    UE_VISUALIZERS_HELPERS \
	REPLACEMENT_OPERATOR_NEW_AND_DELETE \
	UE_DEFINE_FMEMORY_WRAPPERS

PER_MODULE_BOILERPLATE_ANYLINK

#define PER_MODULE_BOILERPLATE_ANYLINK	(		ModuleImplClass,
			ModuleName
	)

REPLACEMENT_OPERATOR_NEW_AND_DELETE

#define REPLACEMENT_OPERATOR_NEW_AND_DELETE

Value:

        FORCENOINLINE OPERATOR_NEW_MSVC_PRAGMA void* operator new  ( size_t Size                                                    ) OPERATOR_NEW_THROW_SPEC      { return FMemory_MallocInline( Size ? Size : 1, Size <= 8 ? 8 : __STDCPP_DEFAULT_NEW_ALIGNMENT__ ); } \
        FORCENOINLINE OPERATOR_NEW_MSVC_PRAGMA void* operator new[]( size_t Size                                                    ) OPERATOR_NEW_THROW_SPEC      { return FMemory_MallocInline( Size ? Size : 1, Size <= 8 ? 8 : __STDCPP_DEFAULT_NEW_ALIGNMENT__ ); } \
        FORCENOINLINE OPERATOR_NEW_MSVC_PRAGMA void* operator new  ( size_t Size,                             const std::nothrow_t& ) OPERATOR_NEW_NOTHROW_SPEC    { return FMemory_MallocInline( Size ? Size : 1, Size <= 8 ? 8 : __STDCPP_DEFAULT_NEW_ALIGNMENT__ ); } \
        FORCENOINLINE OPERATOR_NEW_MSVC_PRAGMA void* operator new[]( size_t Size,                             const std::nothrow_t& ) OPERATOR_NEW_NOTHROW_SPEC    { return FMemory_MallocInline( Size ? Size : 1, Size <= 8 ? 8 : __STDCPP_DEFAULT_NEW_ALIGNMENT__ ); } \
        FORCENOINLINE OPERATOR_NEW_MSVC_PRAGMA void* operator new  ( size_t Size, std::align_val_t Alignment                        ) OPERATOR_NEW_THROW_SPEC      { return FMemory_MallocInline( Size ? Size : 1, (std::size_t)Alignment ); } \
        FORCENOINLINE OPERATOR_NEW_MSVC_PRAGMA void* operator new[]( size_t Size, std::align_val_t Alignment                        ) OPERATOR_NEW_THROW_SPEC      { return FMemory_MallocInline( Size ? Size : 1, (std::size_t)Alignment ); } \
        FORCENOINLINE OPERATOR_NEW_MSVC_PRAGMA void* operator new  ( size_t Size, std::align_val_t Alignment, const std::nothrow_t& ) OPERATOR_NEW_NOTHROW_SPEC    { return FMemory_MallocInline( Size ? Size : 1, (std::size_t)Alignment ); } \
        FORCENOINLINE OPERATOR_NEW_MSVC_PRAGMA void* operator new[]( size_t Size, std::align_val_t Alignment, const std::nothrow_t& ) OPERATOR_NEW_NOTHROW_SPEC    { return FMemory_MallocInline( Size ? Size : 1, (std::size_t)Alignment ); } \
        FORCENOINLINE void operator delete  ( void* Ptr                                                                             ) OPERATOR_DELETE_THROW_SPEC   { FMemory_FreeInline( Ptr ); } \
        FORCENOINLINE void operator delete[]( void* Ptr                                                                             ) OPERATOR_DELETE_THROW_SPEC   { FMemory_FreeInline( Ptr ); } \
        FORCENOINLINE void operator delete  ( void* Ptr,                                                      const std::nothrow_t& ) OPERATOR_DELETE_NOTHROW_SPEC { FMemory_FreeInline( Ptr ); } \
        FORCENOINLINE void operator delete[]( void* Ptr,                                                      const std::nothrow_t& ) OPERATOR_DELETE_NOTHROW_SPEC { FMemory_FreeInline( Ptr ); } \
        FORCENOINLINE void operator delete  ( void* Ptr,             size_t Size                                                    ) OPERATOR_DELETE_THROW_SPEC   { FMemory_FreeInline( Ptr ); } \
        FORCENOINLINE void operator delete[]( void* Ptr,             size_t Size                                                    ) OPERATOR_DELETE_THROW_SPEC   { FMemory_FreeInline( Ptr ); } \
        FORCENOINLINE void operator delete  ( void* Ptr,             size_t Size,                             const std::nothrow_t& ) OPERATOR_DELETE_NOTHROW_SPEC { FMemory_FreeInline( Ptr ); } \
        FORCENOINLINE void operator delete[]( void* Ptr,             size_t Size,                             const std::nothrow_t& ) OPERATOR_DELETE_NOTHROW_SPEC { FMemory_FreeInline( Ptr ); } \
        FORCENOINLINE void operator delete  ( void* Ptr,                          std::align_val_t Alignment                        ) OPERATOR_DELETE_THROW_SPEC   { FMemory_FreeInline( Ptr ); } \
        FORCENOINLINE void operator delete[]( void* Ptr,                          std::align_val_t Alignment                        ) OPERATOR_DELETE_THROW_SPEC   { FMemory_FreeInline( Ptr ); } \
        FORCENOINLINE void operator delete  ( void* Ptr,                          std::align_val_t Alignment, const std::nothrow_t& ) OPERATOR_DELETE_NOTHROW_SPEC { FMemory_FreeInline( Ptr ); } \
        FORCENOINLINE void operator delete[]( void* Ptr,                          std::align_val_t Alignment, const std::nothrow_t& ) OPERATOR_DELETE_NOTHROW_SPEC { FMemory_FreeInline( Ptr ); } \
        FORCENOINLINE void operator delete  ( void* Ptr,             size_t Size, std::align_val_t Alignment                        ) OPERATOR_DELETE_THROW_SPEC   { FMemory_FreeInline( Ptr ); } \
        FORCENOINLINE void operator delete[]( void* Ptr,             size_t Size, std::align_val_t Alignment                        ) OPERATOR_DELETE_THROW_SPEC   { FMemory_FreeInline( Ptr ); } \
        FORCENOINLINE void operator delete  ( void* Ptr,             size_t Size, std::align_val_t Alignment, const std::nothrow_t& ) OPERATOR_DELETE_NOTHROW_SPEC { FMemory_FreeInline( Ptr ); } \
        FORCENOINLINE void operator delete[]( void* Ptr,             size_t Size, std::align_val_t Alignment, const std::nothrow_t& ) OPERATOR_DELETE_NOTHROW_SPEC { FMemory_FreeInline( Ptr ); }

UE_DEFINE_FMEMORY_WRAPPERS

#define UE_DEFINE_FMEMORY_WRAPPERS

Value:

    void* FMemory_Malloc ( size_t Size, size_t Alignment                 ) { return FMemory::Malloc( Size, Alignment ); } \
    void* FMemory_Realloc( void* Original, size_t Size, size_t Alignment ) { return FMemory::Realloc( Original, Size, Alignment ); } \
    void  FMemory_Free   ( void *Ptr                                     ) { FMemory::Free( Ptr ); }

UE_ENABLE_VISUALIZER_HELPERS

#define UE_ENABLE_VISUALIZER_HELPERS   1

UE_VISUALIZER_USE_AND_RETAIN

#define UE_VISUALIZER_USE_AND_RETAIN

UE_VISUALIZERS_HELPERS

#define UE_VISUALIZERS_HELPERS

Value:

        UE_VISUALIZER_USE_AND_RETAIN uint8** GNameBlocksDebug = FNameDebugVisualizer(FClangKeepDebugInfo{}).GetBlocks(); \
        UE_VISUALIZER_USE_AND_RETAIN FChunkedFixedUObjectArray*& GObjectArrayForDebugVisualizers = GCoreObjectArrayForDebugVisualizers; \
        UE_VISUALIZER_USE_AND_RETAIN UE::CoreUObject::Private::FStoredObjectPathDebug*& GComplexObjectPathDebug = GCoreComplexObjectPathDebug; \
        UE_VISUALIZER_USE_AND_RETAIN UE::CoreUObject::Private::FObjectHandlePackageDebugData*& GObjectHandlePackageDebug = GCoreObjectHandlePackageDebug; \
        UE_VISUALIZER_USE_AND_RETAIN UE::Core::FVisualizerDebuggingState*& GDebuggingState = GCoreDebuggingState;