OrcLib: Utils: add EnumFlags.h

src/OrcLib/CMakeLists.txt

@@ -605,6 +605,7 @@ set(SRC_UTILITIES
     "OrcResult.h"
     "Flags.cpp"
     "Flags.h"
+    "Utils/EnumFlags.h"
     "Utils/Guard.h"
     "Utils/Iconv.cpp"
     "Utils/Iconv.h"

src/OrcLib/Utils/EnumFlags.h

@@ -0,0 +1,85 @@
+#pragma once
+
+//
+// Define operators to enable combining enum class values as flags.
+//
+// To enable EnumFlags features use:
+//
+// namespace Foo {
+//   ...
+//   ENABLE_BITMASK_OPERATORS(FilesystemAttributes);
+// }
+//
+// From http://blog.bitwigglers.org/using-enum-classes-as-type-safe-bitmasks/
+//
+
+#include <type_traits>
+
+namespace Orc {
+
+template <typename Enum>
+struct EnableBitMaskOperators
+{
+    static const bool enable = false;
+};
+
+template <typename Enum>
+typename std::enable_if<EnableBitMaskOperators<Enum>::enable, bool>::type constexpr operator&(Enum lhs, Enum rhs)
+{
+    using underlying = typename std::underlying_type<Enum>::type;
+    return static_cast<underlying>(lhs) & static_cast<underlying>(rhs);
+}
+
+template <typename Enum>
+typename std::enable_if<EnableBitMaskOperators<Enum>::enable, bool>::type constexpr operator&=(Enum& lhs, Enum rhs)
+{
+    using underlying = typename std::underlying_type<Enum>::type;
+    lhs = static_cast<underlying>(lhs) & static_cast<underlying>(rhs);
+    return lhs;
+}
+
+template <typename Enum>
+typename std::enable_if<EnableBitMaskOperators<Enum>::enable, Enum>::type constexpr operator|(Enum lhs, Enum rhs)
+{
+    using underlying = typename std::underlying_type<Enum>::type;
+    return static_cast<Enum>(static_cast<underlying>(lhs) | static_cast<underlying>(rhs));
+}
+
+template <typename Enum>
+typename std::enable_if<EnableBitMaskOperators<Enum>::enable, Enum>::type constexpr operator|=(Enum& lhs, Enum rhs)
+{
+    using underlying = typename std::underlying_type<Enum>::type;
+    lhs = static_cast<Enum>(static_cast<underlying>(lhs) | static_cast<underlying>(rhs));
+    return lhs;
+}
+
+template <typename Enum>
+typename std::enable_if<EnableBitMaskOperators<Enum>::enable, Enum>::type constexpr operator^(Enum lhs, Enum rhs)
+{
+    using underlying = typename std::underlying_type<Enum>::type;
+    return static_cast<Enum>(static_cast<underlying>(lhs) ^ static_cast<underlying>(rhs));
+}
+
+template <typename Enum>
+typename std::enable_if<EnableBitMaskOperators<Enum>::enable, Enum>::type constexpr operator^=(Enum& lhs, Enum rhs)
+{
+    using underlying = typename std::underlying_type<Enum>::type;
+    lhs = static_cast<Enum>(static_cast<underlying>(lhs) ^ static_cast<underlying>(rhs));
+    return lhs;
+}
+
+template <typename Enum>
+typename std::enable_if<EnableBitMaskOperators<Enum>::enable, Enum>::type constexpr operator~(Enum value)
+{
+    using underlying = typename std::underlying_type<Enum>::type;
+    return static_cast<Enum>(static_cast<underlying>(value));
+}
+
+#define ENABLE_BITMASK_OPERATORS(x)                                                                                    \
+    template <>                                                                                                        \
+    struct EnableBitMaskOperators<x>                                                                                   \
+    {                                                                                                                  \
+        static const bool enable = true;                                                                               \
+    };
+
+}  // namespace Orc