Macros.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "CeresEngine/Config.hpp"
 
#include <cassert>
 
//
// Operating system platform macro definitions.
//
// These conditionals specify in which Operating System the generated code will
// run. Indention is used to show which conditionals are evolutionary subclasses.
//
//  CE_PLATFORM_WINDOWS             - Generated code will run under Windows.
//      CE_PLATFORM_WIN32           - Generated code will run under WIN32 API.
//  CE_PLATFORM_POSIX               - Generated code will run under some POSIX-compliant OS (including macOS).
//      CE_PLATFORM_LINUX           - Generated code will run under Linux.
//          CE_PLATFORM_ANDROID     - Generated code will run under Android.
//      CE_PLATFORM_BSD             - Generated code will run under a BSD system.
//          CE_PLATFORM_FREEBSD     - Generated code will run under a FreeBSD system.
//      CE_PLATFORM_APPLE           - Generated code will run under an Apple operating system.
//          CE_PLATFORM_MAC         - Generated code will run under macOS.
//          CE_PLATFORM_IOS         - Generated code will run under iOS.
//      CE_PLATFORM_WEB             - Generated code will run on the web.
//          CE_PLATFORM_EMSCRIPTEN  - Generated code will run on the web with Emscripten.
//          CE_PLATFORM_WASI        - Generated code will run on the web with WASI.
//          CE_PLATFORM_CHEERP      - Generated code will run on the web with Cheerp.
//
 
#define CE_PLATFORM_WINDOWS 0 
#define CE_PLATFORM_WIN32 0 
#define CE_PLATFORM_POSIX 0 
#define CE_PLATFORM_LINUX 0 
#define CE_PLATFORM_ANDROID 0 
#define CE_PLATFORM_BSD 0 
#define CE_PLATFORM_FREEBSD 0 
#define CE_PLATFORM_APPLE 0 
#define CE_PLATFORM_MAC 0 
#define CE_PLATFORM_IOS 0 
#define CE_PLATFORM_WEB 0 
#define CE_PLATFORM_EMSCRIPTEN 0 
#define CE_PLATFORM_WASI 0 
#define CE_PLATFORM_CHEERP 0 
 
#if defined(__WIN32__) || defined(_WIN32)
#undef CE_PLATFORM_WINDOWS
#define CE_PLATFORM_WINDOWS 1
 
#undef CE_PLATFORM_WIN32
#define CE_PLATFORM_WIN32 1
#elif defined(__APPLE__)
#undef CE_PLATFORM_POSIX
#define CE_PLATFORM_POSIX 1
 
#undef CE_PLATFORM_APPLE
#define CE_PLATFORM_APPLE 1
 
#include <TargetConditionals.h>
#if TARGET_OS_OSX
#undef CE_PLATFORM_MAC
#define CE_PLATFORM_MAC 1
#elif TARGET_OS_IPHONE
#undef CE_PLATFORM_IOS
#define CE_PLATFORM_IOS 1
#endif
#elif defined(__EMSCRIPTEN__)
#undef CE_PLATFORM_POSIX
#define CE_PLATFORM_POSIX 1
 
#undef CE_PLATFORM_WEB
#define CE_PLATFORM_WEB 1
 
#undef CE_PLATFORM_EMSCRIPTEN
#define CE_PLATFORM_EMSCRIPTEN 1
#elif defined(__wasi__)
#undef CE_PLATFORM_WEB
#define CE_PLATFORM_WEB 1
 
#undef CE_PLATFORM_WASI
#define CE_PLATFORM_WASI 1
#elif defined(__linux__)
#undef CE_PLATFORM_POSIX
#define CE_PLATFORM_POSIX 1
 
#undef CE_PLATFORM_LINUX
#define CE_PLATFORM_LINUX 1
#else
#pragma error "Unknown platform."
#endif
 
//
// Compiler macro definitions.
//  CE_COMPILER_CLANG     - Code will be compiled with Clang.
//  CE_COMPILER_MSVC      - Code will be compiled with MSVC.
//  CE_COMPILER_CLANGCL   - Code will be compiled with Clang (with ClangCL).
//  CE_COMPILER_GNUC      - Code will be compiled with GCC.
//  CE_COMPILER_INTEL     - Code will be compiled with Intel compiler.
//
 
#define CE_COMPILER_CLANG 0 
#define CE_COMPILER_MSVC 0 
#define CE_COMPILER_CLANGCL 0 
#define CE_COMPILER_GNUC 0 
#define CE_COMPILER_INTEL 0 
 
#if defined(__clang__)
#undef CE_COMPILER_CLANG
#define CE_COMPILER_CLANG 1
 
// clang-cl defines _MSC_VER
#if defined(_MSC_VER)
#undef CE_COMPILER_CLANGCL
#define CE_COMPILER_CLANGCL 1
 
#undef CE_COMPILER_MSVC
#define CE_COMPILER_MSVC 1
#endif
#elif defined(__GNUC__) // Check after Clang, as Clang defines this too
#undef CE_COMPILER_GNUC
#define CE_COMPILER_GNUC 1
#elif defined(__INTEL_COMPILER)
#undef CE_COMPILER_INTEL
#define CE_COMPILER_INTEL 1
#elif defined(_MSC_VER) // Check after Clang and Intel, since we could be building with either within VS
#undef CE_COMPILER_MSVC
#define CE_COMPILER_MSVC 1
#else
#pragma error "Unknown compiler."
#endif
 
//
// CPU architecture macro definitions.
//
// These conditionals specify which microprocessor instruction set is being
// generated.  At most one of these is true, the rest are false.
//
//
//  CE_ARCHITECTURE_X86          - Compiler is generating x86 instructions.
//      CE_ARCHITECTURE_X86_32   - Compiler is generating x86 instructions for 32-bit mode
//      CE_ARCHITECTURE_X86_64   - Compiler is generating x86 instructions for 64-bit mode
//  CE_ARCHITECTURE_ARM          - Compiler is generating ARM instructions.
//      CE_ARCHITECTURE_ARM32    - Compiler is generating ARM instructions for 32-bit mode
//      CE_ARCHITECTURE_ARM64    - Compiler is generating ARM instructions for 64-bit mode
//  CE_ARCHITECTURE_WASM          - Compiler is generating WebAssembly instructions.
//      CE_ARCHITECTURE_WASM32    - Compiler is generating WebAssembly instructions for 32-bit mode
//      CE_ARCHITECTURE_WASM64    - Compiler is generating WebAssembly instructions for 64-bit mode
//
 
#define CE_ARCHITECTURE_X86 0 
#define CE_ARCHITECTURE_X86_32 0 
#define CE_ARCHITECTURE_X86_64 0 
#define CE_ARCHITECTURE_ARM 0 
#define CE_ARCHITECTURE_ARM32 0 
#define CE_ARCHITECTURE_ARM64 0 
#define CE_ARCHITECTURE_WASM 0 
#define CE_ARCHITECTURE_WASM32 0 
#define CE_ARCHITECTURE_WASM64 0 
 
#define CE_ARCHITECTURE_IS_32BIT CE_ARCHITECTURE_X86_32 || CE_ARCHITECTURE_ARM32 || CE_ARCHITECTURE_WASM32 
#define CE_ARCHITECTURE_IS_64BIT CE_ARCHITECTURE_X86_64 || CE_ARCHITECTURE_ARM64 || CE_ARCHITECTURE_WASM64 
 
// Find the architecture type
#if defined(__x86_64__) || defined(_M_X64)
#undef CE_ARCHITECTURE_X86
#define CE_ARCHITECTURE_X86 1
 
#undef CE_ARCHITECTURE_X86_64
#define CE_ARCHITECTURE_X86_64 1
#elif defined(i386) || defined(__i386__) || defined(__i386) || defined(_M_IX86)
#undef CE_ARCHITECTURE_X86
#define CE_ARCHITECTURE_X86 1
 
#undef CE_ARCHITECTURE_X86_32
#define CE_ARCHITECTURE_X86_32 1
#elif defined(__aarch64__) || defined(_M_ARM64)
#undef CE_ARCHITECTURE_ARM
#define CE_ARCHITECTURE_ARM 1
 
#undef CE_ARCHITECTURE_ARM64
#define CE_ARCHITECTURE_ARM64 1
#elif defined(__arm__) || defined(_M_ARM)
#undef CE_ARCHITECTURE_ARM
#define CE_ARCHITECTURE_ARM 1
 
#undef CE_ARCHITECTURE_ARM32
#define CE_ARCHITECTURE_ARM32 1
#elif defined(__wasm32__)
#undef CE_ARCHITECTURE_WASM
#define CE_ARCHITECTURE_WASM 1
 
#undef CE_ARCHITECTURE_WASM32
#define CE_ARCHITECTURE_WASM32 1
#elif defined(__wasm64__)
#undef CE_ARCHITECTURE_WASM
#define CE_ARCHITECTURE_WASM 1
 
#undef CE_ARCHITECTURE_WASM64
#define CE_ARCHITECTURE_WASM64 1
#else
#pragma error "Unknown architecture."
#endif
 
// DLL export, import and symbol hiding.
 
#if CE_PLATFORM_WIN32
#define CE_DLL_EXPORT __declspec(dllexport) 
#define CE_DLL_IMPORT __declspec(dllimport) 
#define CE_HIDDEN 
#else
#define CE_VISIBLE __attribute__((visibility("default"))) 
#define CE_HIDDEN __attribute__((visibility("hidden"))) 
#define CE_DLL_EXPORT CE_VISIBLE 
#define CE_DLL_IMPORT CE_VISIBLE 
#endif
 
#if defined(CE_SHARED_LIB)
#if defined(CE_EXPORTS)
#define CE_EXPORT CE_DLL_EXPORT 
#else
#define CE_EXPORT CE_DLL_IMPORT 
#endif
#else
#define CE_EXPORT 
#endif
 
#if defined(__has_attribute)
#if __has_attribute(annotate)
#define CE_SCRIPT_EXPORT(...) __attribute__((annotate("ce-scriptable:" #__VA_ARGS__)))
#else
#define CE_SCRIPT_EXPORT(...)
#endif
#else
#define CE_SCRIPT_EXPORT(...)
#endif
 
#if defined(__has_attribute)
#if __has_attribute(annotate)
#define CEReflectable(...) clang::annotate("ce-reflectable:" #__VA_ARGS__)
#else
#define CEReflectable(...)
#endif
#else
#define CEReflectable(...)
#endif
 
#define CE_BIND_THIS(function)                                        \
    [this](auto&&... args) -> decltype(auto) {                        \
        return this->function(std::forward<decltype(args)>(args)...); \
    }
 
#define CE_DEPRECATED [[deprecated]]
#define CE_DEPRECATED_MSG(Message) [[deprecated(Message)]]
 
// -- Nullability Attributes
//
// Whether a particular pointer may be “null” is an important concern when
// working with pointers in the C family of languages. The various nullability
// attributes indicate whether a particular pointer can be null or not, which
// makes APIs more expressive and can help static analysis tools identify bugs
// involving null pointers.
//
// The nullability (type) qualifiers express whether a value of a given pointer
// type can be null (the `CE_NULLABLE` qualifier), doesn't have a defined
// meaning for null (the `CE_NON_NULL` qualifier), or for which the purpose of
// null is unclear (the `CE_NULL_UNSPECIFIED` qualifier). Nullability
// qualifiers are written to the right of the pointer to which they apply.
//
 
#if CE_COMPILER_CLANG
#define CE_NON_NULL _Nonnull 
#define CE_NULLABLE _Nullable 
#define CE_NULL_UNSPECIFIED \
    _Null_unspecified 
#else
#define CE_NON_NULL 
#define CE_NULLABLE 
#define CE_NULL_UNSPECIFIED 
#endif
 
#if defined(__has_attribute)
#if __has_attribute(expects)
#define CE_EXPECTS(...) [[expects:__VA_ARGS__]]
#else
#define CE_EXPECTS(...)
#endif
#if __has_attribute(ensures)
#define CE_ENSURES(...) [[ensures:__VA_ARGS__]]
#else
#define CE_ENSURES(...)
#endif
#if __has_attribute(assert)
#define CE_ASSERT(...) [[assert:__VA_ARGS__]]
#else
#define CE_ASSERT(x) assert(x)
#endif
#else
#define CE_EXPECTS(...)
#define CE_ENSURES(...)
#define CE_ASSERT(...) assert(__VA_ARGS__)
#endif
 
#define CE_ASSERT_UNDEFINED()                 \
    CE_ASSERT(false && "Undefined Behavior"); \
    std::terminate();
#define CE_ASSERT_UNIMPLEMENTED()          \
    CE_ASSERT(false && "Not Implemented"); \
    std::terminate();
 
#if !defined(NDEBUG)
#define CE_ASSERT_DEBUG(...) CE_ASSERT(__VA_ARGS__)
#else
#define CE_ASSERT_DEBUG(...)
#endif
 
#if defined(__cpp_concepts)
#define CE_CONCEPT_REQUIRES(...) requires __VA_ARGS__
#else
#define CE_CONCEPT(Name) typename
#define CE_CONCEPT_REQUIRES(...)
#endif
 
#if CE_COMPILER_MSVC
#define CE_NOINLINE __declspec(noinline)
#elif CE_COMPILER_CLANG || CE_COMPILER_GNUC
#define CE_NOINLINE [[gnu::noinline]]
#else
#define CE_NOINLINE
#endif
 
#if CE_COMPILER_MSVC
#define CE_UNREACHABLE __assume(false)
#elif CE_COMPILER_CLANG || CE_COMPILER_GNUC
#define CE_UNREACHABLE __builtin_unreachable()
#else
#define CE_UNREACHABLE std::abort()
#endif
 
#if CE_COMPILER_MSVC
#define CE_FORCE_INLINE __forceinline
#elif CE_COMPILER_CLANG || CE_COMPILER_GNUC
#define CE_FORCE_INLINE __attribute__((always_inline))
#else
#define CE_FORCE_INLINE
#endif
 
#if CE_COMPILER_MSVC
#define CE_FLATTEN_INLINE __forceinline
#elif CE_COMPILER_CLANG || CE_COMPILER_GNUC
#define CE_FLATTEN_INLINE [[gnu::flatten]]
#else
#define CE_FORCE_INLINE
#endif
 
#if CE_COMPILER_CLANG || CE_COMPILER_GNUC
#define CE_COLD [[gnu::cold]]
#else
#define CE_COLD
#endif
 
#if defined(__has_cpp_attribute)
#if __has_cpp_attribute(likely)
#define CE_LIKELY [[likely]]
#else
#define CE_LIKELY
#endif
#if __has_cpp_attribute(unlikely)
#define CE_UNLIKELY [[unlikely]]
#else
#define CE_UNLIKELY
#endif
#else
#define CE_LIKELY
#define CE_UNLIKELY
#endif
 
#if defined(__has_cpp_attribute)
#if __has_cpp_attribute(no_unique_address)
#define CE_NO_UNIQUE_ADDRESS [[no_unique_address]]
#else
#define CE_NO_UNIQUE_ADDRESS
#endif
#else
#define CE_NO_UNIQUE_ADDRESS
#endif
 
#if defined(__cpp_conditional_explicit)
#define CE_EXPLICIT(EXPR) explicit(EXPR)
#else
#define CE_EXPLICIT(EXPR)
#endif
 
#define CE_EXPLICIT_FALSE CE_EXPLICIT(false)
 
// clang-format off
 
#if CE_COMPILER_MSVC
#   define CE_DISABLE_WARNING_PUSH           __pragma(warning(push))
#   define CE_DISABLE_WARNING_POP            __pragma(warning(pop))
#   define CE_DISABLE_WARNING(warningNumber) __pragma(warning(disable : warningNumber))
#   define CE_DISABLE_ALL_WARNINGS           __pragma(warning(push, 0))
 
#   define CE_DISABLE_WARNING_UNREFERENCED_FORMAL_PARAMETER     CE_DISABLE_WARNING(4100)
#   define CE_DISABLE_WARNING_UNREFERENCED_FUNCTION             CE_DISABLE_WARNING(4505)
#   define CE_DISABLE_WARNING_TAUTOLOGICAL_COMPARE              
#   define CE_DISABLE_WARNING_REORDER                           CE_DISABLE_WARNING(5038)
#   define CE_DISABLE_WARNING_UNUSED_VARIABLE                   CE_DISABLE_WARNING(4189)
#   define CE_DISABLE_WARNING_UNINITIALIZED_VARIABLE            CE_DISABLE_WARNING(4701) CE_DISABLE_WARNING(4703)
#   define CE_DISABLE_WARNING_MISSING_FIELD_INITIALIZERS        
#   define CE_DISABLE_WARNING_UNUSED_PRIVATE_FIELD              
#   define CE_DISABLE_WARNING_TYPE_LIMITS                       
#   define CE_DISABLE_WARNING_DEPRECATED_VOLATILE               
#   define CE_DISABLE_WARNING_DEPRECATED_DECLARATIONS           CE_DISABLE_WARNING(4996)
#   define CE_DISABLE_WARNING_UNSIGNED_UNARY_MINUS              CE_DISABLE_WARNING(4146)
#   define CE_DISABLE_WARNING_IMPLICIT_LOSSY_CONVERSION         CE_DISABLE_WARNING(4244)
#   define CE_DISABLE_WARNING_MISSING_OVERRIDE
#   define CE_DISABLE_WARNING_INHERITS_VIA_DOMINANCE            CE_DISABLE_WARNING(4250)
#   define CE_DISABLE_WARNING_DESTRUCTOR_IMPLICITLY_DELETED     CE_DISABLE_WARNING(4624)
 
#elif CE_COMPILER_CLANG || CE_COMPILER_GNUC
#   define CE_DO_PRAGMA(X) _Pragma(#X)
#   define CE_DISABLE_WARNING_STRINGIFY(x) #x
#   if CE_COMPILER_CLANG
#       define CE_DISABLE_WARNING_PUSH  CE_DO_PRAGMA(clang diagnostic push)
#       define CE_DISABLE_WARNING_POP   CE_DO_PRAGMA(clang diagnostic pop)
#       define CE_DISABLE_WARNING(name) CE_DO_PRAGMA(clang diagnostic ignored #name)
#       define CE_DISABLE_ALL_WARNINGS  CE_DO_PRAGMA(clang diagnostic ignored "-Weverything")
#   elif CE_COMPILER_GNUC
#       define CE_DISABLE_WARNING_PUSH  CE_DO_PRAGMA(GCC diagnostic push)
#       define CE_DISABLE_WARNING_POP   CE_DO_PRAGMA(GCC diagnostic pop)
#       define CE_DISABLE_WARNING(name) CE_DO_PRAGMA(GCC diagnostic ignored #name)
#       define CE_DISABLE_ALL_WARNINGS
#   else
#       error Unsupported compiler!
#   endif
#   define CE_DISABLE_WARNING_UNREFERENCED_FORMAL_PARAMETER     CE_DISABLE_WARNING(-Wunused-parameter)
#   define CE_DISABLE_WARNING_UNREFERENCED_FUNCTION             CE_DISABLE_WARNING(-Wunused-function)
#   define CE_DISABLE_WARNING_TAUTOLOGICAL_COMPARE              CE_DISABLE_WARNING(-Wtautological-compare)
#   define CE_DISABLE_WARNING_REORDER                           CE_DISABLE_WARNING(-Wreorder)
#   define CE_DISABLE_WARNING_UNUSED_VARIABLE                   CE_DISABLE_WARNING(-Wunused-variable)
#   define CE_DISABLE_WARNING_UNINITIALIZED_VARIABLE            CE_DISABLE_WARNING(-Wuninitialized)
#   define CE_DISABLE_WARNING_MISSING_FIELD_INITIALIZERS        CE_DISABLE_WARNING(-Wmissing-field-initializers)
#   define CE_DISABLE_WARNING_UNUSED_PRIVATE_FIELD              CE_DISABLE_WARNING(-Wunused-private-field)
#   define CE_DISABLE_WARNING_TYPE_LIMITS                       CE_DISABLE_WARNING(-Wtype-limits)
#if CE_COMPILER_CLANG
#   define CE_DISABLE_WARNING_DEPRECATED_VOLATILE               CE_DISABLE_WARNING(-Wdeprecated-volatile)
#else
#   define CE_DISABLE_WARNING_DEPRECATED_VOLATILE               /* no-op */
#endif
#   define CE_DISABLE_WARNING_DEPRECATED_DECLARATIONS           CE_DISABLE_WARNING(-Wdeprecated-declarations)
#   define CE_DISABLE_WARNING_UNSIGNED_UNARY_MINUS              /* no-op */
#   define CE_DISABLE_WARNING_IMPLICIT_LOSSY_CONVERSION         /* no-op */
#if CE_COMPILER_CLANG
#   define CE_DISABLE_WARNING_MISSING_OVERRIDE                  CE_DISABLE_WARNING(-Winconsistent-missing-override)
#else
#   define CE_DISABLE_WARNING_MISSING_OVERRIDE                  /* no-op */
#endif
#   define CE_DISABLE_WARNING_INHERITS_VIA_DOMINANCE            /* no-op */
#   define CE_DISABLE_WARNING_DESTRUCTOR_IMPLICITLY_DELETED     /* no-op */
#else
#   define CE_DISABLE_WARNING_PUSH
#   define CE_DISABLE_WARNING_POP
#   define CE_DISABLE_ALL_WARNINGS
 
#   define CE_DISABLE_WARNING_UNREFERENCED_FORMAL_PARAMETER
#   define CE_DISABLE_WARNING_UNREFERENCED_FUNCTION
#   define CE_DISABLE_WARNING_TAUTOLOGICAL_COMPARE
#   define CE_DISABLE_WARNING_REORDER
#   define CE_DISABLE_WARNING_UNUSED_VARIABLE
#   define CE_DISABLE_WARNING_UNINITIALIZED_VARIABLE
#   define CE_DISABLE_WARNING_MISSING_FIELD_INITIALIZERS
#   define CE_DISABLE_WARNING_UNUSED_PRIVATE_FIELD
#   define CE_DISABLE_WARNING_TYPE_LIMITS
#   define CE_DISABLE_WARNING_DEPRECATED_VOLATILE
#   define CE_DISABLE_WARNING_DEPRECATED_DECLARATIONS
#   define CE_DISABLE_WARNING_UNSIGNED_UNARY_MINUS
#   define CE_DISABLE_WARNING_UNSIGNED_UNARY_MINUS
#   define CE_DISABLE_WARNING_INHERITS_VIA_DOMINANCE
#   define CE_DISABLE_WARNING_DESTRUCTOR_IMPLICITLY_DELETED
#endif
 
// ---------------------------------------------------------------------------------------------
 
#if CE_COMPILER_MSVC
#define CE_ASSUME(X) __assume(X)
#else
#define CE_ASSUME(X)
#endif
 
#if CE_COMPILER_MSVC
#define CE_CPU_CACHE_LINE std::hardware_destructive_interference_size
#else
// On most architectures we can assume a 64-byte cache line.
#define CE_CPU_CACHE_LINE 64
#endif
 
// ---------------------------------------------------------------------------------------------
 
// clang-format on
 
#define CE_TOKENPASTE2_(x, y) x##y
#define CE_TOKENPASTE2(x, y) CE_TOKENPASTE2_(x, y)
 
#define CE_TOKENPASTE3_(x, y, z) x##y##z
#define CE_TOKENPASTE3(x, y, z) CE_TOKENPASTE3_(x, y, z)
 
#define CE_USES_ALLOCATOR(T) \
    template<typename Alloc> struct std::uses_allocator<T, Alloc> : std::true_type {}
 
#define FMT_CONSTEVAL
 
#define GLM_FORCE_RADIANS
#define GLM_FORCE_DEPTH_ZERO_TO_ONE
#define GLM_ENABLE_EXPERIMENTAL
 
// -------------------------------------------------------------------------------------------------
 
#define CE_REFL_DATA(N) RTTI.template data<&std::decay_t<decltype(RTTI)>::ReflectedType::N>(#N)
#define CE_REFL_DATA_NAMED(N, M) RTTI.template data<&std::decay_t<decltype(RTTI)>::ReflectedType::M>(#N)
 
#if CE_COMPILER_MSVC
#define CE_REFL_DATA_GET(N, G) RTTI.data(#N, [](const typename std::decay_t<decltype(RTTI)>::ReflectedType* obj) { return obj->G(); })
#define CE_REFL_DATA_GETSET(N, G, S) RTTI.template data<&std::decay_t<decltype(RTTI)>::ReflectedType::G, &std::decay_t<decltype(RTTI)>::ReflectedType::S>(#N)
#else
#define CE_REFL_DATA_GET(N, G) RTTI.template data(#N, [](const typename std::decay_t<decltype(RTTI)>::ReflectedType* obj) { return obj->G(); })
#define CE_REFL_DATA_GETSET(N, G, S) RTTI.template data<&std::decay_t<decltype(RTTI)>::ReflectedType::G, &std::decay_t<decltype(RTTI)>::ReflectedType::S>(#N)
#endif
 
#define CE_REFL_FUNC(N) RTTI.template func<&std::decay_t<decltype(RTTI)>::ReflectedType::N>(#N)
#define CE_REFL_CTOR(...) RTTI.template ctor<__VA_ARGS__>()
#define CE_REFL_VAL(N) RTTI.template value<std::decay_t<decltype(RTTI)>::ReflectedType::N>(#N)
#define CE_REFL_BASE(T) RTTI.template base<T>()
 
// ---------------------------------------------------------------------------------------------
 
#ifdef __has_attribute
#if __has_attribute(swift_attr)
// clang-format off
#define CE_SWIFT_SELF_CONTAINED __attribute__((swift_attr("import_owned")))
#define CE_SWIFT_SAFE_TO_IMPORT __attribute__((swift_attr("import_unsafe")))
 
#define _CXX_INTEROP_STRINGIFY(_x) #_x
#define CE_SWIFT_REFERENCE_TYPE(_retain, _release)                             \
  __attribute__((swift_attr("import_reference")))                              \
  __attribute__((swift_attr(_CXX_INTEROP_STRINGIFY(retain:_retain))))          \
  __attribute__((swift_attr(_CXX_INTEROP_STRINGIFY(release:_release))))
// clang-format on
#else
#define CE_SWIFT_SELF_CONTAINED
#define CE_SWIFT_SAFE_TO_IMPORT
#define CE_SWIFT_REFERENCE_TYPE(_retain, _release)
#endif
 
#if defined(__has_attribute) && __has_attribute(swift_name)
#define CE_SWIFT_NAME(_name) __attribute__((swift_name(#_name)))
#else
#define CE_SWIFT_NAME(_name)
#endif
#else
#define CE_SWIFT_SELF_CONTAINED
#define CE_SWIFT_SAFE_TO_IMPORT
#define CE_SWIFT_REFERENCE_TYPE(_retain, _release)
#define CE_SWIFT_NAME(_name)
#endif