Add enum class flag definition to platform

Author: pea-pod

platform/mbed_enum_flags.h

@@ -0,0 +1,158 @@
+/*
+ * Copyright (c) 2020 ARM Limited. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef MBED_SCOPED_ENUM_FLAGS_H
+#define MBED_SCOPED_ENUM_FLAGS_H
+
+#ifdef __cplusplus
+#include <type_traits>
+
+#define ENUM_FLAG_OPERATOR(T,OP) \
+inline constexpr T operator OP( T lhs, T rhs) {\
+    return ( T ) ( \
+        static_cast<std::underlying_type< T >::type>(lhs) OP \
+        static_cast<std::underlying_type< T >::type>(rhs)); \
+};
+
+
+#define ENUM_FLAG_OPERATOR_LHS_REFERNCE(T, X) \
+inline T & operator X (T & a, T b) { \
+    a = a X b; \
+    return a; \
+}
+
+
+/**
+ * @brief Applies bitwise operators to a enum class defined elsewhere.
+ *
+ * @param T             The enum class typename
+ *
+ * This macro applies the bitwise negate, AND, OR, XOR operators and the
+ * corresponding assigment operators to an existing enum class. The macro
+ * uses underlying type traits to convert back and forth.
+ *
+ * Due to the way the macro works, there is no semicolon required at the end.
+ *
+ * Usage:
+ * @code
+ * external_enum.h:
+ *
+ * enum class SpokenLanguages : uint8_t {
+ *     Sindarin    = (1 << 0),
+ *     Westron     = (1 << 1),
+ *     Rohirric    = (1 << 2),
+ *     BlackSpeech = (1 << 3)
+ * };
+ *
+ * my_code.cpp:
+ *
+ * #include "mbed_enum_flags.h"
+ * #include "external_enum.h"
+ *
+ * MBED_ENUM_FLAG_APPLY_OPERATORS(SpokenLanguages)
+ *
+ * SpokenLanguages gandalf = SpokenLanguages::Sindarin | SpokenLanguages::Westron |
+ *     SpokenLanguages::Rohirric | SpokenLanguages::BlackSpeech;
+ * @endcode
+ *
+ */
+#define MBED_ENUM_FLAG_APPLY_OPERATORS(T) \
+\
+inline constexpr T operator ~( T lhs) { \
+    return ( T ) (~static_cast<std::underlying_type< T >::type>(lhs)) ;\
+}\
+ENUM_FLAG_OPERATOR(T, |)\
+ENUM_FLAG_OPERATOR(T, ^)\
+ENUM_FLAG_OPERATOR(T, &)\
+ENUM_FLAG_OPERATOR_LHS_REFERNCE(T, |=) \
+ENUM_FLAG_OPERATOR_LHS_REFERNCE(T, ^=) \
+ENUM_FLAG_OPERATOR_LHS_REFERNCE(T, &=) \
+
+
+#define MBED_SCOPED_ENUM_FLAGS_TYPED(T, UNDER_TYPE) \
+enum class T : UNDER_TYPE; \
+MBED_ENUM_FLAG_APPLY_OPERATORS(T) \
+enum class T : UNDER_TYPE
+
+#define MBED_SCOPED_ENUM_FLAGS_UNTYPED(T) \
+enum class T; \
+MBED_ENUM_FLAG_APPLY_OPERATORS(T) \
+enum class T
+
+#define MBED_SCOPED_ENUM_FLAGS_CHOOSER(_1, _2, NAME, ...) NAME
+
+/**
+ * @brief Creates an enum class with bitwise operator overloads.
+ *
+ * @param T             The enum class typename
+ * @param UNDER_TYPE    Optional: specify the underlying integral type. If left blank will
+ *                      default to the compiler default (by standard, an int)
+ *
+ * This macro creates both the enum class type and defines NOT, AND, OR, and
+ * XOR operators. It also defines as three bitwise assignment operators, AND,
+ * OR, and XOR. It allows for the scoped nature of the enum class, but adds back
+ * the bitwise operators that were missing.
+ *
+ * This macro uses type traits to convert between the underlying type and back
+ * again for the bitwise operations.
+ *
+ * Usage:
+ * @code
+ * my_nice_enum_class_with_flags.h:
+ *
+ * MBED_SCOPED_ENUM_FLAGS(MyFlagName) {
+ *     HasEars    = (1 << 0),
+ *     HasFur     = (1 << 1),
+ *     LaysEggs   = (1 << 2),
+ *     Meows      = (1 << 3),
+ *     Polydactyl = (1 << 30)
+ * };
+ *
+ * MBED_SCOPED_ENUM_FLAGS(SpokenLanguages, uint8_t) {
+ *     Sindarin    = (1 << 0),
+ *     Westron     = (1 << 1),
+ *     Rohirric    = (1 << 2),
+ *     BlackSpeech = (1 << 3)
+ * }
+ *
+ * my_enum_class_flag_consumer.h:
+ *
+ * class EnumEater {
+ * public:
+ *     EnumEater(MyFlagName flags) : _flags(flags) {}
+ *
+ *     static MyFlagName DefaultFlags = MyFlagName::HasEars | MyFlagName::Meows;
+ *
+ *     bool is_cat() const {
+ *         return ( ((_flags & DefaultFlags) == DefaultFlags) &&
+ *             ((_flags & MyFlagName::LaysEggs) == MyFlagName()) );
+ *     }
+ * private:
+ *     MyFlagName _flags;
+ * };
+ *
+ * bool is_Gandalf(SpokenLanguages flags) {
+ *     return flags == (SpokenLanguages::Sindarin | SpokenLanguages::Westron |
+ *         SpokenLanguages::SpeaksRohirric | SpokenLanguages::BlackSpeech);
+ * }
+ * @endcode
+ *
+ */
+#define MBED_SCOPED_ENUM_FLAGS(...) MBED_SCOPED_ENUM_FLAGS_CHOOSER(__VA_ARGS__, MBED_SCOPED_ENUM_FLAGS_TYPED, MBED_SCOPED_ENUM_FLAGS_UNTYPED)(__VA_ARGS__)
+
+#endif // __cplusplus
+
+#endif //MBED_SCOPED_ENUM_FLAGS_H