Macros.h

Go to the documentation of this file.

#pragma once
 
#include <type_traits>

#define SOURCEPP_CONCAT_DETAIL(a, b) a##b
#define SOURCEPP_CONCAT(a, b) SOURCEPP_CONCAT_DETAIL(a, b)

#define SOURCEPP_DEFAULT_COPY(Clazz) \
    Clazz(const Clazz&) = default; \
    Clazz& operator=(const Clazz&) = default

#define SOURCEPP_DEFAULT_MOVE(Clazz) \
    Clazz(Clazz&&) noexcept = default; \
    Clazz& operator=(Clazz&&) noexcept = default
 
// Defaults copy and move constructors
#define SOURCEPP_DEFAULT_COPY_OR_MOVE(Clazz) \
    SOURCEPP_DEFAULT_COPY(Clazz); \
    SOURCEPP_DEFAULT_MOVE(Clazz)

#define SOURCEPP_NO_COPY(Clazz) \
    Clazz(const Clazz&) = delete; \
    Clazz& operator=(const Clazz&) = delete

#define SOURCEPP_NO_MOVE(Clazz) \
    Clazz(Clazz&&) noexcept = delete; \
    Clazz& operator=(Clazz&&) noexcept = delete
 
// Deletes copy and move constructors
#define SOURCEPP_NO_COPY_OR_MOVE(Clazz) \
    SOURCEPP_NO_COPY(Clazz); \
    SOURCEPP_NO_MOVE(Clazz)

#ifdef DEBUG
    #if defined(_MSC_VER)
        #define SOURCEPP_DEBUG_BREAK __debugbreak()
    #elif defined(__linux__)
        #include <csignal>
        #define SOURCEPP_DEBUG_BREAK std::raise(SIGINT)
    #endif
#endif
#ifndef SOURCEPP_DEBUG_BREAK
    #define SOURCEPP_DEBUG_BREAK
#endif

#define SOURCEPP_DEBUG_ASSERT(cond) do { if (!(cond)) { SOURCEPP_DEBUG_BREAK; } } while (false)

#define SOURCEPP_UNIQUE_NAME(base) SOURCEPP_CONCAT(base, __LINE__)

#define SOURCEPP_BITFLAGS_ENUM(Enum)                          \
    template<typename T>                                      \
    requires std::is_same_v<T, Enum> || std::is_integral_v<T> \
    inline constexpr Enum operator|(Enum lhs, T rhs) {        \
        return static_cast<Enum>(                             \
            static_cast<std::underlying_type_t<Enum>>(lhs) |  \
            static_cast<std::underlying_type_t<Enum>>(rhs));  \
    }                                                         \
    template<typename T>                                      \
    requires std::is_same_v<T, Enum> || std::is_integral_v<T> \
    inline constexpr Enum operator&(Enum lhs, T rhs) {        \
        return static_cast<Enum>(                             \
            static_cast<std::underlying_type_t<Enum>>(lhs) &  \
            static_cast<std::underlying_type_t<Enum>>(rhs));  \
    }                                                         \
    template<typename T>                                      \
    requires std::is_same_v<T, Enum> || std::is_integral_v<T> \
    inline constexpr Enum operator^(Enum lhs, T rhs) {        \
        return static_cast<Enum>(                             \
            static_cast<std::underlying_type_t<Enum>>(lhs) ^  \
            static_cast<std::underlying_type_t<Enum>>(rhs));  \
    }                                                         \
    inline constexpr Enum operator~(Enum e) {                 \
        return static_cast<Enum>(                             \
            ~static_cast<std::underlying_type_t<Enum>>(e));   \
    }                                                         \
    template<typename T>                                      \
    requires std::is_same_v<T, Enum> || std::is_integral_v<T> \
    inline constexpr Enum& operator|=(Enum& lhs, T rhs) {     \
        return lhs = static_cast<Enum>(                       \
            static_cast<std::underlying_type_t<Enum>>(lhs) |  \
            static_cast<std::underlying_type_t<Enum>>(rhs));  \
    }                                                         \
    template<typename T>                                      \
    requires std::is_same_v<T, Enum> || std::is_integral_v<T> \
    inline constexpr Enum& operator&=(Enum& lhs, T rhs) {     \
        return lhs = static_cast<Enum>(                       \
            static_cast<std::underlying_type_t<Enum>>(lhs) &  \
            static_cast<std::underlying_type_t<Enum>>(rhs));  \
    }                                                         \
    template<typename T>                                      \
    requires std::is_same_v<T, Enum> || std::is_integral_v<T> \
    inline constexpr Enum& operator^=(Enum& lhs, T rhs) {     \
        return lhs = static_cast<Enum>(                       \
            static_cast<std::underlying_type_t<Enum>>(lhs) ^  \
            static_cast<std::underlying_type_t<Enum>>(rhs));  \
    }