Add support for Compiler::StaticType bitmasking

Author: adazem009

CMakeLists.txt

@@ -26,6 +26,7 @@ install(TARGETS scratchcpp DESTINATION lib)
 target_sources(scratchcpp
   PUBLIC
     include/scratchcpp/global.h
+    include/scratchcpp/enum_bitmask.h
     include/scratchcpp/project.h
     include/scratchcpp/scratchconfiguration.h
     include/scratchcpp/iengine.h

include/scratchcpp/compiler.h

@@ -6,6 +6,7 @@
 #include <vector>
 
 #include "global.h"
+#include "enum_bitmask.h"
 #include "spimpl.h"
 
 namespace libscratchcpp
@@ -31,12 +32,12 @@ class LIBSCRATCHCPP_EXPORT Compiler
     public:
         enum class StaticType
         {
-            Void,
-            Number,
-            Bool,
-            String,
-            Pointer,
-            Unknown
+            Void = 0,
+            Number = 1 << 0,
+            Bool = 1 << 1,
+            String = 1 << 2,
+            Pointer = 1 << 3,
+            Unknown = Number | Bool | String
         };
 
         enum class CodeType
@@ -161,4 +162,6 @@ class LIBSCRATCHCPP_EXPORT Compiler
         spimpl::unique_impl_ptr<CompilerPrivate> impl;
 };
 
+constexpr bool enable_enum_bitmask(Compiler::StaticType);
+
 } // namespace libscratchcpp

include/scratchcpp/enum_bitmask.h

@@ -0,0 +1,53 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <type_traits>
+
+namespace libscratchcpp
+{
+
+// https://andreasfertig.com/blog/2024/01/cpp20-concepts-applied
+// OR operator |
+template<typename T>
+constexpr std::enable_if_t<std::conjunction_v<std::is_enum<T>, std::is_same<bool, decltype(enable_enum_bitmask(std::declval<T>()))>>, T> operator|(const T lhs, const T rhs)
+{
+    using underlying = std::underlying_type_t<T>;
+    return static_cast<T>(static_cast<underlying>(lhs) | static_cast<underlying>(rhs));
+}
+
+// OR assignment operator |=
+template<typename T>
+constexpr std::enable_if_t<std::conjunction_v<std::is_enum<T>, std::is_same<bool, decltype(enable_enum_bitmask(std::declval<T>()))>>, T &> operator|=(T &lhs, const T rhs)
+{
+    using underlying = std::underlying_type_t<T>;
+    lhs = static_cast<T>(static_cast<underlying>(lhs) | static_cast<underlying>(rhs));
+    return lhs;
+}
+
+// AND operator &
+template<typename T>
+constexpr std::enable_if_t<std::conjunction_v<std::is_enum<T>, std::is_same<bool, decltype(enable_enum_bitmask(std::declval<T>()))>>, T> operator&(const T lhs, const T rhs)
+{
+    using underlying = std::underlying_type_t<T>;
+    return static_cast<T>(static_cast<underlying>(lhs) & static_cast<underlying>(rhs));
+}
+
+// AND assignment operator &=
+template<typename T>
+constexpr std::enable_if_t<std::conjunction_v<std::is_enum<T>, std::is_same<bool, decltype(enable_enum_bitmask(std::declval<T>()))>>, T &> operator&=(T &lhs, const T rhs)
+{
+    using underlying = std::underlying_type_t<T>;
+    lhs = static_cast<T>(static_cast<underlying>(lhs) & static_cast<underlying>(rhs));
+    return lhs;
+}
+
+// NOT operator ~
+template<typename T>
+constexpr std::enable_if_t<std::conjunction_v<std::is_enum<T>, std::is_same<bool, decltype(enable_enum_bitmask(std::declval<T>()))>>, T> operator~(const T value)
+{
+    using underlying = std::underlying_type_t<T>;
+    return static_cast<T>(~static_cast<underlying>(value));
+}
+
+} // namespace libscratchcpp