Common: Add flag helper class

Author: f3sch

Common/Utils/include/CommonUtils/Flags.h

@@ -0,0 +1,179 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+#ifndef O2_FRAMEWORK_ENUM_BIT_OPERATORS_H_
+#define O2_FRAMEWORK_ENUM_BIT_OPERATORS_H_
+
+#include <type_traits>
+#include <string>
+#include <sstream>
+#include <limits>
+
+namespace o2::flags
+{
+
+template <typename E>
+concept EFlag = requires {
+  requires std::is_enum_v<E>;
+  requires std::is_unsigned_v<std::underlying_type_t<E>>;
+  requires std::is_convertible_v<std::underlying_type_t<E>, size_t>;
+};
+
+// Promote an enum to a functioning flag class. The underlying type is
+// the one behind the enum, when bitset becomes constexpr and we get
+// reflection one could changes this.
+template <EFlag E>
+class Flags
+{
+  using U = std::underlying_type_t<E>;
+  U mBits{0};
+
+  constexpr auto to_underlying(E e) const noexcept
+  {
+    return static_cast<U>(e);
+  }
+
+  constexpr auto to_bit(E e) const noexcept
+  {
+    return U(1) << to_underlying(e);
+  }
+
+ public:
+  constexpr explicit Flags() = default;
+  constexpr explicit Flags(E e) : mBits(to_bit(e)) {}
+  constexpr explicit Flags(const Flags&) = default;
+  constexpr explicit Flags(U u) : mBits(u) {}
+  constexpr explicit Flags(std::initializer_list<E> flags) noexcept
+  {
+    for (E flag : flags) {
+      mBits |= to_bit(flag);
+    }
+  }
+
+  static constexpr U None{0};
+  static constexpr U All{std::numeric_limits<U>::max()};
+
+  void set(std::string& s, int base = 2)
+  {
+    if (base == 2) { // check of only 0 and 1 in string
+      if (!std::all_of(s.begin(), s.end(), [](char c) { return c == '0' || c == '1'; })) {
+        throw std::invalid_argument("Invalid binary string.");
+      }
+    }
+    mBits = static_cast<U>(std::stoul(s, nullptr, base));
+  }
+
+  constexpr auto value() const noexcept
+  {
+    return mBits;
+  }
+
+  constexpr void reset() noexcept
+  {
+    mBits = U(0);
+  }
+
+  template <typename T>
+    requires std::is_same_v<T, E>
+  constexpr void reset(T t)
+  {
+    mBits &= ~to_bit(t);
+  }
+
+  template <typename T>
+    requires std::is_same_v<T, E>
+  constexpr bool test(T t) const noexcept
+  {
+    return (mBits & to_bit(t)) != None;
+  }
+
+  constexpr bool any() const noexcept
+  {
+    return mBits != None;
+  }
+
+  std::string string() const
+  {
+    std::ostringstream oss;
+    oss << std::bitset<std::numeric_limits<U>::digits>(mBits);
+    return oss.str();
+  }
+
+  constexpr explicit operator bool() const noexcept
+  {
+    return any();
+  }
+
+  constexpr bool operator==(const Flags& o) const noexcept
+  {
+    return mBits == o.mBits;
+  }
+
+  constexpr bool operator!=(const Flags& o) const noexcept
+  {
+    return mBits != o.mBits;
+  }
+
+  constexpr Flags& operator=(const Flags& o) = default;
+
+  template <typename T>
+    requires std::is_same_v<T, E>
+  constexpr Flags& operator|=(T t) noexcept
+  {
+    mBits |= to_bit(t);
+    return *this;
+  }
+
+  template <typename T>
+    requires std::is_same_v<T, E>
+  constexpr Flags operator&=(T t) noexcept
+  {
+    mBits |= to_bit(t);
+    return *this;
+  }
+
+  template <typename T>
+    requires std::is_same_v<T, E>
+  constexpr Flags operator&(T t) const noexcept
+  {
+    return Flags(mBits & to_bit(t));
+  }
+  constexpr Flags operator~() const noexcept
+  {
+    return Flags(~mBits);
+  }
+
+  constexpr Flags operator|(const Flags& o) const noexcept
+  {
+    return Flags(mBits | o.mBits);
+  }
+
+  constexpr Flags& operator|=(const Flags& o) noexcept
+  {
+    mBits |= o.mBits;
+    return *this;
+  }
+
+  template <typename... Ts>
+  constexpr bool all_of(Ts... flags) const noexcept
+  {
+    return ((test(flags) && ...));
+  }
+
+  template <typename... Ts>
+  constexpr bool none_of(Ts... flags) const noexcept
+  {
+    return (!(test(flags) || ...));
+  }
+};
+
+} // namespace o2::flags
+
+#endif