Common: Add flag helper class

Author: f3sch

Common/Utils/CMakeLists.txt

@@ -81,6 +81,12 @@ o2_add_test(MemFileHelper
             SOURCES test/testMemFileHelper.cxx
             PUBLIC_LINK_LIBRARIES O2::CommonUtils)
 
+o2_add_test(Flags
+            COMPONENT_NAME CommonUtils
+            LABELS utils
+            SOURCES test/testFlags.cxx
+            PUBLIC_LINK_LIBRARIES O2::CommonUtils)
+
 o2_add_executable(treemergertool
             COMPONENT_NAME CommonUtils
           SOURCES src/TreeMergerTool.cxx

Common/Utils/include/CommonUtils/Flags.h

@@ -0,0 +1,284 @@
+// 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_FLAGS_H_
+#define O2_FRAMEWORK_FLAGS_H_
+
+#include <stdexcept>
+#include <type_traits>
+#include <string>
+#include <sstream>
+#include <limits>
+#include <bitset>
+#include <initializer_list>
+#include <cstdint>
+#include <cstddef>
+
+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};
+
+  // Converts enum to its underlying type.
+  constexpr auto to_underlying(E e) const noexcept
+  {
+    return static_cast<U>(e);
+  }
+
+  // Returns the bit representation of a flag.
+  constexpr auto to_bit(E e) const noexcept
+  {
+    return U(1) << to_underlying(e);
+  }
+
+ public:
+  // Default constructor.
+  constexpr explicit Flags() = default;
+  // Constructor to initialize with a single flag.
+  constexpr explicit Flags(E e) : mBits(to_bit(e)) {}
+  // Copy constructor.
+  constexpr Flags(const Flags&) = default;
+  // Move constructor.
+  constexpr Flags(Flags&&) = default;
+  // Constructor to initialize with the underlyiny type.
+  constexpr explicit Flags(U u) : mBits(u) {}
+  // Initialize with a list of flags.
+  constexpr Flags(std::initializer_list<E> flags) noexcept
+  {
+    for (E flag : flags) {
+      mBits |= to_bit(flag);
+    }
+  }
+  // Destructor.
+  constexpr ~Flags() = default;
+
+  static constexpr U None{0};                                  // Represents no flags set.
+  static constexpr U All{std::numeric_limits<U>::max()};       // Represents all flags set.
+  static constexpr U Digits{std::numeric_limits<U>::digits()}; // Maximum number of bits in the underlying type.
+
+  // Sets flags from a string representation.
+  void set(const 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.");
+      }
+    }
+    uint64_t v = std::stoul(s, nullptr, base);
+    if (v > std::numeric_limits<U>::max()) {
+      throw std::out_of_range("Values exceeds underlying type range.");
+    }
+    mBits = static_cast<U>(v);
+  }
+
+  // Returns the raw bitset value.
+  constexpr auto value() const noexcept
+  {
+    return mBits;
+  }
+
+  // Resets all flags.
+  constexpr void reset() noexcept
+  {
+    mBits = U(0);
+  }
+
+  // Resets a specific flag.
+  template <typename T>
+    requires std::is_same_v<T, E>
+  constexpr void reset(T t)
+  {
+    mBits &= ~to_bit(t);
+  }
+
+  // Tests if a specific flag is set.
+  template <typename T>
+    requires std::is_same_v<T, E>
+  [[nodiscard]] constexpr bool test(T t) const noexcept
+  {
+    return (mBits & to_bit(t)) != None;
+  }
+
+  // Toggles a specific flag.
+  template <typename T>
+    requires std::is_same_v<T, E>
+  constexpr void toggle(T t) noexcept
+  {
+    mBits ^= to_bit(t);
+  }
+
+  // Checks if any flag is set.
+  [[nodiscard]] constexpr bool any() const noexcept
+  {
+    return mBits != None;
+  }
+
+  // Returns the bitset as a binary string.
+  [[nodiscard]] std::string string() const
+  {
+    std::ostringstream oss;
+    oss << std::bitset<std::numeric_limits<U>::digits>(mBits);
+    return oss.str();
+  }
+
+  // Checks if any flag is set (Boolean context).
+  constexpr explicit operator bool() const noexcept
+  {
+    return any();
+  }
+
+  // Checks if two flag sets are equal.
+  constexpr bool operator==(const Flags& o) const noexcept
+  {
+    return mBits == o.mBits;
+  }
+
+  // Checks if two flag sets are not equal.
+  constexpr bool operator!=(const Flags& o) const noexcept
+  {
+    return mBits != o.mBits;
+  }
+
+  // Copy assignment operator
+  constexpr Flags& operator=(const Flags& o) = default;
+
+  // Move assignment operator
+  constexpr Flags& operator=(Flags&& o) = default;
+
+  // Performs a bitwise OR with a flag.
+  template <typename T>
+    requires std::is_same_v<T, E>
+  constexpr Flags& operator|=(T t) noexcept
+  {
+    mBits |= to_bit(t);
+    return *this;
+  }
+
+  // Performs a bitwise AND with a flag.
+  template <typename T>
+    requires std::is_same_v<T, E>
+  constexpr Flags& operator&=(T t) noexcept
+  {
+    mBits &= to_bit(t);
+    return *this;
+  }
+
+  // Returns a flag set with a bitwise AND.
+  template <typename T>
+    requires std::is_same_v<T, E>
+  constexpr Flags operator&(T t) const noexcept
+  {
+    return Flags(mBits & to_bit(t));
+  }
+
+  // Returns a flag set with all bits inverted.
+  constexpr Flags operator~() const noexcept
+  {
+    return Flags(~mBits);
+  }
+
+  // Performs a bitwise OR with another flag set.
+  constexpr Flags operator|(const Flags& o) const noexcept
+  {
+    return Flags(mBits | o.mBits);
+  }
+
+  // Performs a bitwise OR assignment.
+  constexpr Flags& operator|=(const Flags& o) noexcept
+  {
+    mBits |= o.mBits;
+    return *this;
+  }
+
+  // Performs a bitwise XOR with another flag set.
+  constexpr Flags operator^(const Flags& o) const noexcept
+  {
+    return Flags(mBits ^ o.mBits);
+  }
+
+  // Performs a bitwise XOR assignment.
+  constexpr Flags& operator^=(const Flags& o) noexcept
+  {
+    mBits ^= o.mBits;
+    return *this;
+  }
+
+  // Checks if all specified flags are set.
+  template <typename... Ts>
+  constexpr bool all_of(Ts... flags) const noexcept
+  {
+    return ((test(flags) && ...));
+  }
+
+  // Checks if none of the specified flags are set.
+  template <typename... Ts>
+  constexpr bool none_of(Ts... flags) const noexcept
+  {
+    return (!(test(flags) || ...));
+  }
+
+  // Serializes the flag set to a string.
+  [[nodiscard]] std::string serialize() const
+  {
+    return std::to_string(mBits);
+  }
+
+  // Deserializes a string into the flag set.
+  void deserialize(const std::string& data)
+  {
+    uint64_t v = std::stoul(data);
+    if (v > std::numeric_limits<U>::max()) {
+      throw std::out_of_range("Values exceeds underlying type range.");
+    }
+    mBits = static_cast<U>(v);
+  }
+
+  // Counts the number of set bits (active flags).
+  [[nodiscard]] constexpr size_t count() const noexcept
+  {
+    return std::bitset<Digits>(mBits).count();
+  }
+
+  // Returns the union of two flag sets.
+  constexpr Flags union_with(const Flags& o) const noexcept
+  {
+    return Flags(mBits | o.mBits);
+  }
+
+  // Returns the intersection of two flag sets.
+  constexpr Flags intersection_with(const Flags& o) const noexcept
+  {
+    return Flags(mBits & o.mBits);
+  }
+
+  // Checks if all flags in another Flags object are present in the current object.
+  constexpr bool contains(const Flags& other) const noexcept
+  {
+    return (mBits & other.mBits) == other.mBits;
+  }
+};
+
+} // namespace o2::flags
+
+#endif