CoreMiscDefines.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "HAL/Platform.h"
#include "HAL/PreprocessorHelpers.h"
 
// When passed to pragma message will result in clickable warning in VS
#define WARNING_LOCATION(Line) __FILE__ "(" PREPROCESSOR_TO_STRING(Line) ")"
 
// This file is included in some resource files, which issue a warning:
//
// warning RC4011: identifier truncated to 'PLATFORM_CAN_SUPPORT_EDITORONLY'
//
// due to limitations of resource compiler. The only thing needed from this file
// for resource compilation is PREPROCESSOR_TO_STRING macro at the end, so we take
// rest of code out for resource compilation.
#ifndef RC_INVOKED
 
#define PLAYWORLD_PACKAGE_PREFIX TEXT("UEDPIE")
 
#ifndef WITH_EDITORONLY_DATA
    #if !PLATFORM_CAN_SUPPORT_EDITORONLY_DATA || UE_SERVER || PLATFORM_IOS
        #define WITH_EDITORONLY_DATA    0
    #else
        #define WITH_EDITORONLY_DATA    1
    #endif
#endif
 
#ifndef WITH_METADATA
#define WITH_METADATA WITH_EDITORONLY_DATA
#elif WITH_EDITORONLY_DATA && !WITH_METADATA
#error WITH_EDITORONLY_DATA=1 requires WITH_METADATA=1
#endif
 
// Option to check for UE_DISABLE_OPTIMIZATION being submitted
#ifndef UE_CHECK_DISABLE_OPTIMIZATION
#define UE_CHECK_DISABLE_OPTIMIZATION 0
#endif
 
// Set up optimization control macros, now that we have both the build settings and the platform macros
 
// Defines for submitting optimizations off
#define UE_DISABLE_OPTIMIZATION_SHIP  PRAGMA_DISABLE_OPTIMIZATION_ACTUAL
 
//in debug keep optimizations off for the enable macro otherwise code following enable will be optimized
#if UE_BUILD_DEBUG
    #define UE_ENABLE_OPTIMIZATION_SHIP  PRAGMA_DISABLE_OPTIMIZATION_ACTUAL
#else
    #define UE_ENABLE_OPTIMIZATION_SHIP  PRAGMA_ENABLE_OPTIMIZATION_ACTUAL
#endif
 
// if running on a build machine assert on the dev optimizations macros to validate that code is not being submitted with optimizations off
#if UE_CHECK_DISABLE_OPTIMIZATION
    #define UE_DISABLE_OPTIMIZATION static_assert(false, "Error UE_DISABLE_OPTIMIZATION submitted. Use UE_DISABLE_OPTIMIZATION_SHIP to submit with optimizations off.");
    #define UE_ENABLE_OPTIMIZATION static_assert(false, "Error UE_ENABLE_OPTIMIZATION submitted. Use UE_ENABLE_OPTIMIZATION_SHIP to submit with optimizations off.");
#else
    #define UE_DISABLE_OPTIMIZATION  UE_DISABLE_OPTIMIZATION_SHIP
    #define UE_ENABLE_OPTIMIZATION  UE_ENABLE_OPTIMIZATION_SHIP
#endif
 
#define PRAGMA_DISABLE_OPTIMIZATION \
    UE_DEPRECATED_MACRO(5.2, "PRAGMA_DISABLE_OPTIMIZATION has been deprecated. Use UE_DISABLE_OPTIMIZATION for temporary development or UE_DISABLE_OPTIMIZATION_SHIP to submit") \
    UE_DISABLE_OPTIMIZATION_SHIP
 
#define PRAGMA_ENABLE_OPTIMIZATION  \
    UE_DEPRECATED_MACRO(5.2, "PRAGMA_ENABLE_OPTIMIZATION has been deprecated. Use UE_ENABLE_OPTIMIZATION for temporary development or UE_ENABLE_OPTIMIZATION_SHIP to submit") \
    UE_ENABLE_OPTIMIZATION_SHIP
 
#if UE_BUILD_DEBUG
    #define FORCEINLINE_DEBUGGABLE FORCEINLINE_DEBUGGABLE_ACTUAL
#else
    #define FORCEINLINE_DEBUGGABLE FORCEINLINE
#endif
 
// Macro to disable inlining of function calls within the statement that follows
// e.g: UE_DONT_INLINE_CALL ThisFunctionCallWontBeInlined(Foo->ThisIsntInlinedEither());
#if !defined(UE_DONT_INLINE_CALL)
    #if defined(__clang__) && defined(__has_cpp_attribute) && __has_cpp_attribute(clang::noinline)
        #define UE_DONT_INLINE_CALL [[clang::noinline]]
    #else
        #define UE_DONT_INLINE_CALL
    #endif
#endif
 
 
#if STATS
    #define CLOCK_CYCLES(Timer)   {Timer -= FPlatformTime::Cycles();}
    #define UNCLOCK_CYCLES(Timer) {Timer += FPlatformTime::Cycles();}
#else
    #define CLOCK_CYCLES(Timer)
    #define UNCLOCK_CYCLES(Timer)
#endif
 
#define SHUTDOWN_IF_EXIT_REQUESTED
#define RETURN_IF_EXIT_REQUESTED
#define RETURN_VAL_IF_EXIT_REQUESTED(x)
 
#if CHECK_PUREVIRTUALS
#define PURE_VIRTUAL(func,...) =0;
#else
#define PURE_VIRTUAL(func,...) { LowLevelFatalError(TEXT("Pure virtual not implemented (%s)"), TEXT(#func)); __VA_ARGS__ }
#endif
 
 
// Code analysis features
#ifndef USING_CODE_ANALYSIS
    #define USING_CODE_ANALYSIS 0
#endif
 
#if USING_CODE_ANALYSIS
    #if !defined( CA_IN ) || !defined( CA_OUT ) || !defined( CA_READ_ONLY ) || !defined( CA_WRITE_ONLY ) || !defined( CA_VALID_POINTER ) || !defined( CA_CHECK_RETVAL ) || !defined( CA_NO_RETURN ) || !defined( CA_SUPPRESS ) || !defined( CA_ASSUME )
        #error Code analysis macros are not configured correctly for this platform
    #endif
#else
    // Just to be safe, define all of the code analysis macros to empty macros
    #define CA_IN 
    #define CA_OUT
    #define CA_READ_ONLY
    #define CA_WRITE_ONLY
    #define CA_VALID_POINTER
    #define CA_CHECK_RETVAL
    #define CA_NO_RETURN
    #define CA_SUPPRESS( WarningNumber )
    #define CA_ASSUME( Expr ) ((void)sizeof((bool)(Expr)))
    #define CA_CONSTANT_IF(Condition) if (Condition)
#endif
 
#ifndef USING_INSTRUMENTATION
    #define USING_INSTRUMENTATION 0
#endif
 
#ifndef USING_THREAD_SANITISER
    #define USING_THREAD_SANITISER 0
#endif
 
#if USING_THREAD_SANITISER || USING_INSTRUMENTATION
    #if !defined( TSAN_SAFE ) || !defined( TSAN_BEFORE ) || !defined( TSAN_AFTER ) || !defined( TSAN_ATOMIC )
        #error Thread Sanitiser macros are not configured correctly for this platform
    #endif
#else
    // Define TSAN macros to empty when not enabled
    #define TSAN_SAFE
    #define TSAN_BEFORE(Addr)
    #define TSAN_AFTER(Addr)
    #define TSAN_ATOMIC(Type) Type
#endif
 
enum {INDEX_NONE    = -1                };
enum {UNICODE_BOM   = 0xfeff            };
 
enum EForceInit 
{
    ForceInit,
    ForceInitToZero
};
enum ENoInit {NoInit};
// Used to add an explicitly consteval constructor when the default constructor for a type cannot
// be made constexpr (e.g. we are attempting to avoid zero-initialization when constructing at runtime)
enum EConstEval {ConstEval};
enum EInPlace {InPlace};
enum EPerElement {PerElement};
 
#endif // RC_INVOKED
 
// Push and pop macro definitions
#ifdef __clang__
    #define UE_PUSH_MACRO(name) _Pragma(PREPROCESSOR_TO_STRING(push_macro(name)))
    #define UE_POP_MACRO(name) _Pragma(PREPROCESSOR_TO_STRING(pop_macro(name)))
#else
    #define UE_PUSH_MACRO(name) __pragma(push_macro(name))
    #define UE_POP_MACRO(name) __pragma(pop_macro(name))
#endif
 
#ifdef __COUNTER__
    // Created a variable with a unique name
    #define ANONYMOUS_VARIABLE( Name ) PREPROCESSOR_JOIN(Name, __COUNTER__)
#else
    // Created a variable with a unique name.
    // Less reliable than the __COUNTER__ version.
    #define ANONYMOUS_VARIABLE( Name ) PREPROCESSOR_JOIN(Name, __LINE__)
#endif
 
#define UE_CALL_ONCE(Func, ...) static int32 ANONYMOUS_VARIABLE(ThreadSafeOnce) = ((Func)(__VA_ARGS__), 1)
 
#if defined (__INTELLISENSE__)
 
    #define UE_DEPRECATED(Version, Message)
    #define UE_INTERNAL
    #define PRAGMA_DISABLE_INTERNAL_WARNINGS 
    #define PRAGMA_ENABLE_INTERNAL_WARNINGS 
    #define UE_EXPERIMENTAL(Version, Message)
    #define PRAGMA_DISABLE_EXPERIMENTAL_WARNINGS 
    #define PRAGMA_ENABLE_EXPERIMENTAL_WARNINGS 
 
#else // defined (__INTELLISENSE__)
    
    #define UE_DEPRECATED(Version, Message) [[deprecated(Message " - Please update your code to the new API before upgrading to the next release, otherwise your project will no longer compile.")]]
 
    struct FDeprecationCompileError {};
    #define UE_DEPRECATED_ERROR(Version, Message) [[deprecated(Message " - ** This is a compile error so as to avoid data loss, or similar. ** You will need to update your code to get it to compile correctly.")]]
    
    #define UE_DEPRECATED_ERROR_WITH_MOVED_MEMBER_MESSAGE(Version, Member, Message) \
        [[deprecated(Message " ** This is a compile error so as to avoid data loss, or similar. ** You will need to update your code to get it to compile correctly.")]] \
        FDeprecationCompileError Member;
    
    #define UE_DEPRECATED_ERROR_WITH_MOVED_MEMBER(Version, Member) UE_DEPRECATED_ERROR_WITH_MOVED_MEMBER_MESSAGE(Version, Member, "The member " #Member " has moved. Use the Get/Set" #Member " accessors instead.")
 
    #define UE_DEPRECATED_ERROR_WITH_MOVED_BOOL_MEMBER(Version, Member) UE_DEPRECATED_ERROR_WITH_MOVED_MEMBER_MESSAGE(Version, b##Member, "The member b" #Member " has moved. Use the Get/Set" #Member " accessors instead.")
 
    #if UE_VALIDATE_INTERNAL_API 
        #define UE_INTERNAL [[deprecated("This API is internal to the engine. As such, there is no guarantee that it won't change or be removed in future releases. Please use at your own risk.")]]
        #define PRAGMA_DISABLE_INTERNAL_WARNINGS PRAGMA_DISABLE_DEPRECATION_WARNINGS
        #define PRAGMA_ENABLE_INTERNAL_WARNINGS PRAGMA_ENABLE_DEPRECATION_WARNINGS
    #else // UE_VALIDATE_INTERNAL_API 
        #define UE_INTERNAL
        #define PRAGMA_DISABLE_INTERNAL_WARNINGS 
        #define PRAGMA_ENABLE_INTERNAL_WARNINGS 
    #endif // !UE_VALIDATE_INTERNAL_API 
 
    #if UE_VALIDATE_EXPERIMENTAL_API
        #define UE_EXPERIMENTAL(Version, Message)  [[deprecated(Message " - This API is experimental. As such, there is no guarantee that it won't change or be removed in future releases. Please use at your own risk.")]]
        #define PRAGMA_DISABLE_EXPERIMENTAL_WARNINGS PRAGMA_DISABLE_DEPRECATION_WARNINGS
        #define PRAGMA_ENABLE_EXPERIMENTAL_WARNINGS PRAGMA_ENABLE_DEPRECATION_WARNINGS
    #else // UE_VALIDATE_EXPERIMENTAL_API
        #define UE_EXPERIMENTAL(Version, Message)
        #define PRAGMA_DISABLE_EXPERIMENTAL_WARNINGS 
        #define PRAGMA_ENABLE_EXPERIMENTAL_WARNINGS 
    #endif // !UE_VALIDATE_EXPERIMENTAL_API
 
#endif // !defined(__INTELLISENSE__)
 
#ifndef UE_DEPRECATED_FORGAME
    #define UE_DEPRECATED_FORGAME PREPROCESSOR_NOTHING_FUNCTION
#endif
 
#ifndef UE_DEPRECATED_FORENGINE
    #define UE_DEPRECATED_FORENGINE UE_DEPRECATED
#endif
 
 
#if defined(UE_DIRECT_HEADER_COMPILE)
    // Don't warn about the deprecated header when we are directly compiling the header
    #define UE_DEPRECATED_HEADER(Version, Message)
#elif defined(_MSC_VER)
    #if UE_WARNINGS_AS_ERRORS
        #define UE_DEPRECATED_HEADER(Version, Message) __pragma(message(__FILE__ "(" PREPROCESSOR_TO_STRING(__LINE__) "): error C4996: " Message " Please update your code to the new API before upgrading to the next release, otherwise your project will no longer compile."))
    #else
        #define UE_DEPRECATED_HEADER(Version, Message) __pragma(message(__FILE__ "(" PREPROCESSOR_TO_STRING(__LINE__) "): warning C4996: " Message " Please update your code to the new API before upgrading to the next release, otherwise your project will no longer compile."))
    #endif
#else
    #define UE_DEPRECATED_HEADER(Version, Message) _Pragma(PREPROCESSOR_TO_STRING(message(Message " Please update your code to the new API before upgrading to the next release, otherwise your project will no longer compile.")))
#endif
 
 
/*
 * Macro that can be defined in the target file to strip deprecated properties in objects across the engine that check against this define.
 * Can be used by project that have migrated away from using deprecated functions and data members to potentially gain back some memory and perf.
 * @note This is a define that engine developer may use when deprecating properties to allow additional memory savings when a project is compliant with deprecation notice.
 * It doesn't indicate that all deprecated properties will be stripped.
 */
#ifndef UE_STRIP_DEPRECATED_PROPERTIES
    #define UE_STRIP_DEPRECATED_PROPERTIES 0
#endif
 
template <bool bIsDeprecated>
struct TStaticDeprecateExpression
{
};
 
#define UE_STATIC_DEPRECATE(Version, bExpression, Message) \
    struct PREPROCESSOR_JOIN(FDeprecationMsg_, __LINE__) { \
        [[deprecated(Message " - Please update your code to the new API before upgrading to the next release, otherwise your project will no longer compile.")]] \
        static constexpr int condition(TStaticDeprecateExpression<true>) { return 1; } \
        static constexpr int condition(TStaticDeprecateExpression<false>) { return 1; } \
    }; \
    enum class PREPROCESSOR_JOIN(EDeprecationMsg_, __LINE__) { Value = PREPROCESSOR_JOIN(FDeprecationMsg_, __LINE__)::condition(TStaticDeprecateExpression<!!(bExpression)>()) }
 
#define UE_STATIC_ASSERT_WARN(bExpression, Message) \
    struct PREPROCESSOR_JOIN(FStaticWarningMsg_, __LINE__) { \
        [[deprecated(Message)]] \
        static constexpr int condition(TStaticDeprecateExpression<true>) { return 1; } \
        static constexpr int condition(TStaticDeprecateExpression<false>) { return 1; } \
    }; \
    enum class PREPROCESSOR_JOIN(EStaticWarningMsg_, __LINE__) { Value = PREPROCESSOR_JOIN(FStaticWarningMsg_, __LINE__)::condition(TStaticDeprecateExpression<!(bExpression)>()) }
 
// These defines are used to mark a difference between two pointers as expected to fit into the specified range
// while still leaving something searchable if the surrounding code is updated to work with a 64 bit count/range
// in the future
#define UE_PTRDIFF_TO_INT32(argument) static_cast<int32>(argument)
#define UE_PTRDIFF_TO_UINT32(argument) static_cast<uint32>(argument)
 
#define UE_NONCOPYABLE(TypeName) \
    TypeName(TypeName&&) = delete; \
    TypeName(const TypeName&) = delete; \
    TypeName& operator=(const TypeName&) = delete; \
    TypeName& operator=(TypeName&&) = delete;
 
 
struct FPlatformUserId
{
    UE_FORCEINLINE_HINT bool IsValid() const
    {
        return InternalId != INDEX_NONE;
    }
 
    UE_FORCEINLINE_HINT int32 GetInternalId() const
    {
        return InternalId;
    }
 
    inline static FPlatformUserId CreateFromInternalId(int32 InInternalId)
    {
        FPlatformUserId IdToReturn;
        IdToReturn.InternalId = InInternalId;
        return IdToReturn;
    }
 
    UE_FORCEINLINE_HINT bool operator==(const FPlatformUserId& Other) const
    {
        return InternalId == Other.InternalId;
    }
 
    UE_FORCEINLINE_HINT bool operator!=(const FPlatformUserId& Other) const
    {
        return InternalId != Other.InternalId;
    }
 
    UE_FORCEINLINE_HINT friend uint32 GetTypeHash(const FPlatformUserId& UserId)
    {
        return UserId.InternalId;
    }
 
    // This should be deprecated when the online code uniformly handles FPlatformUserId */
    // UE_DEPRECATED(5.x, "Implicit conversion to user index is deprecated, use FPlatformMisc::GetUserIndexForPlatformUser")
    UE_FORCEINLINE_HINT constexpr operator int32() const { return InternalId; }
 
private:
    int32 InternalId = INDEX_NONE;
};
 
inline constexpr FPlatformUserId PLATFORMUSERID_NONE;
 
struct FInputDeviceId
{
    inline static FInputDeviceId CreateFromInternalId(int32 InInternalId)
    {
        FInputDeviceId IdToReturn;
        IdToReturn.InternalId = InInternalId;
        return IdToReturn;
    }
    
    UE_FORCEINLINE_HINT int32 GetId() const
    {
        return InternalId;
    }
 
    UE_FORCEINLINE_HINT bool IsValid() const
    {
        return InternalId >= 0;
    }
 
    UE_FORCEINLINE_HINT bool operator==(const FInputDeviceId& Other) const
    {
        return InternalId == Other.InternalId;
    }
 
    UE_FORCEINLINE_HINT bool operator!=(const FInputDeviceId& Other) const
    {
        return InternalId != Other.InternalId;
    }
    
    UE_FORCEINLINE_HINT bool operator<(const FInputDeviceId& Other) const
    {
        return InternalId < Other.InternalId;
    }
 
    UE_FORCEINLINE_HINT bool operator<=(const FInputDeviceId& Other) const
    {
        return InternalId <= Other.InternalId;
    }
 
    UE_FORCEINLINE_HINT bool operator>(const FInputDeviceId& Other) const
    {
        return InternalId > Other.InternalId;
    }
 
    UE_FORCEINLINE_HINT bool operator>=(const FInputDeviceId& Other) const
    {
        return InternalId >= Other.InternalId;
    }
 
    UE_FORCEINLINE_HINT friend uint32 GetTypeHash(const FInputDeviceId& InputId)
    {
        return InputId.InternalId;
    }
    
private:
    
    int32 InternalId = INDEX_NONE;
};
 
inline constexpr FInputDeviceId INPUTDEVICEID_NONE;
 
enum class EInputDeviceConnectionState : uint8
{
    Invalid,
 
    Unknown,
 
    Disconnected,
 
    Connected
};
 
struct FPlatformInputDeviceState
{
    FPlatformUserId OwningPlatformUser = PLATFORMUSERID_NONE;
 
    EInputDeviceConnectionState ConnectionState = EInputDeviceConnectionState::Invalid;
};
 
#ifndef UE_WITH_REMOTE_OBJECT_HANDLE
    #define UE_WITH_REMOTE_OBJECT_HANDLE 0
#endif