mirror of
https://github.com/SerenityOS/serenity
synced 2026-04-25 17:15:42 +02:00
320d08efef
These overloads return void, since GCC otherwise complains if you
ignore the return value:
implicit dereference will not access object of type
'volatile Kernel::PCI::Registers::Control' in statement [-Werror]
132 | registers->control |= Registers::Control::PERST_N;
| ~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
109 lines
7.0 KiB
C
109 lines
7.0 KiB
C
/*
|
|
* Copyright (c) 2021, Brian Gianforcaro <bgianf@serenityos.org>
|
|
*
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include <AK/StdLibExtraDetails.h>
|
|
|
|
// Enables bitwise operators for the specified Enum type.
|
|
//
|
|
#define AK_ENUM_BITWISE_OPERATORS(Enum) \
|
|
_AK_ENUM_BITWISE_OPERATORS_INTERNAL(Enum, )
|
|
|
|
// Enables bitwise operators for the specified Enum type, this
|
|
// version is meant for use on enums which are private to the
|
|
// containing type.
|
|
//
|
|
#define AK_ENUM_BITWISE_FRIEND_OPERATORS(Enum) \
|
|
_AK_ENUM_BITWISE_OPERATORS_INTERNAL(Enum, friend)
|
|
|
|
#define _AK_ENUM_BITWISE_OPERATORS_INTERNAL(Enum, Prefix) \
|
|
\
|
|
[[nodiscard]] Prefix constexpr Enum operator|(Enum lhs, Enum rhs) \
|
|
{ \
|
|
using Type = UnderlyingType<Enum>; \
|
|
return static_cast<Enum>( \
|
|
static_cast<Type>(lhs) | static_cast<Type>(rhs)); \
|
|
} \
|
|
\
|
|
[[nodiscard]] Prefix constexpr Enum operator&(Enum lhs, Enum rhs) \
|
|
{ \
|
|
using Type = UnderlyingType<Enum>; \
|
|
return static_cast<Enum>( \
|
|
static_cast<Type>(lhs) & static_cast<Type>(rhs)); \
|
|
} \
|
|
\
|
|
[[nodiscard]] Prefix constexpr Enum operator^(Enum lhs, Enum rhs) \
|
|
{ \
|
|
using Type = UnderlyingType<Enum>; \
|
|
return static_cast<Enum>( \
|
|
static_cast<Type>(lhs) ^ static_cast<Type>(rhs)); \
|
|
} \
|
|
\
|
|
[[nodiscard]] Prefix constexpr Enum operator~(Enum rhs) \
|
|
{ \
|
|
using Type = UnderlyingType<Enum>; \
|
|
return static_cast<Enum>( \
|
|
~static_cast<Type>(rhs)); \
|
|
} \
|
|
\
|
|
Prefix constexpr Enum& operator|=(Enum& lhs, Enum rhs) \
|
|
{ \
|
|
using Type = UnderlyingType<Enum>; \
|
|
lhs = static_cast<Enum>( \
|
|
static_cast<Type>(lhs) | static_cast<Type>(rhs)); \
|
|
return lhs; \
|
|
} \
|
|
\
|
|
Prefix inline void operator|=(Enum volatile& lhs, Enum rhs) \
|
|
{ \
|
|
using Type = UnderlyingType<Enum>; \
|
|
lhs = static_cast<Enum>( \
|
|
static_cast<Type>(lhs) | static_cast<Type>(rhs)); \
|
|
} \
|
|
\
|
|
Prefix constexpr Enum& operator&=(Enum& lhs, Enum rhs) \
|
|
{ \
|
|
using Type = UnderlyingType<Enum>; \
|
|
lhs = static_cast<Enum>( \
|
|
static_cast<Type>(lhs) & static_cast<Type>(rhs)); \
|
|
return lhs; \
|
|
} \
|
|
\
|
|
Prefix inline void operator&=(Enum volatile& lhs, Enum rhs) \
|
|
{ \
|
|
using Type = UnderlyingType<Enum>; \
|
|
lhs = static_cast<Enum>( \
|
|
static_cast<Type>(lhs) & static_cast<Type>(rhs)); \
|
|
} \
|
|
\
|
|
Prefix constexpr Enum& operator^=(Enum& lhs, Enum rhs) \
|
|
{ \
|
|
using Type = UnderlyingType<Enum>; \
|
|
lhs = static_cast<Enum>( \
|
|
static_cast<Type>(lhs) ^ static_cast<Type>(rhs)); \
|
|
return lhs; \
|
|
} \
|
|
\
|
|
Prefix inline void operator^=(Enum volatile& lhs, Enum rhs) \
|
|
{ \
|
|
using Type = UnderlyingType<Enum>; \
|
|
lhs = static_cast<Enum>( \
|
|
static_cast<Type>(lhs) ^ static_cast<Type>(rhs)); \
|
|
} \
|
|
\
|
|
Prefix constexpr bool has_flag(Enum value, Enum mask) \
|
|
{ \
|
|
using Type = UnderlyingType<Enum>; \
|
|
return static_cast<Type>(value & mask) == static_cast<Type>(mask); \
|
|
} \
|
|
\
|
|
Prefix constexpr bool has_any_flag(Enum value, Enum mask) \
|
|
{ \
|
|
using Type = UnderlyingType<Enum>; \
|
|
return static_cast<Type>(value & mask) != 0; \
|
|
}
|