AK/EnumBits.h


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

/*
 * Copyright (c) 2021, Brian Gianforcaro <bgianf@serenityos.org>
 *
 * SPDX-License-Identifier: BSD-2-Clause
 */

#pragma once

#include "AK/StdLibExtras.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 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 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 constexpr bool has_flag(Enum value, Enum mask)             \
    {                                                                 \
        using Type = UnderlyingType<Enum>;                            \
        return static_cast<Type>(value & mask) != 0;                  \
    }