FlagSet.h

#pragma once
 
#include <cstdint>
 
namespace iolink
{
 
template <typename EnumType>
class FlagSet
{
public:
  FlagSet()
      : m_value(0)
  {
  }
 
  explicit FlagSet(uint64_t value)
      : m_value(value)
  {
  }
 
  FlagSet(EnumType flags)
      : m_value(static_cast<uint64_t>(flags))
  {
  }
 
  FlagSet(const FlagSet& other) = default;
  FlagSet& operator=(const FlagSet& other) = default;
 
  FlagSet(FlagSet&& other) noexcept = default;
  FlagSet& operator=(FlagSet&& other) noexcept = default;
 
  uint64_t value() const { return m_value; }
 
  bool has(FlagSet flags) const { return (m_value & flags.m_value) == flags.m_value; }
 
  void add(FlagSet flags) { m_value |= flags.m_value; }
 
  void remove(FlagSet flags) { m_value &= ~(flags.m_value); }
 
  bool operator==(FlagSet flags) const { return m_value == flags.m_value; }
 
  bool operator!=(FlagSet flags) const { return m_value != flags.m_value; }
 
  // ================= //
  // Bitwise operators //
  // ================= //
 
  FlagSet& operator|=(FlagSet flags)
  {
    m_value |= flags.m_value;
    return *this;
  }
 
  FlagSet& operator&=(FlagSet flags)
  {
    m_value &= flags.m_value;
    return *this;
  }
 
  FlagSet& operator^=(FlagSet flags)
  {
    m_value ^= flags.m_value;
    return *this;
  }
 
  FlagSet operator|(FlagSet flags) { return flags |= *this; }
 
  FlagSet operator&(FlagSet flags) { return flags &= *this; }
 
  FlagSet operator^(FlagSet flags) { return flags ^= *this; }
 
private:
  uint64_t m_value;
};
 
#define IOLINK_DEFINE_ENUM_BITWISE_OPERATORS(EnumType)                                                     \
  inline FlagSet<EnumType> operator|(EnumType lhs, EnumType rhs) { return FlagSet<EnumType>(lhs) |= rhs; } \
  inline FlagSet<EnumType> operator&(EnumType lhs, EnumType rhs) { return FlagSet<EnumType>(lhs) &= rhs; } \
  inline FlagSet<EnumType> operator^(EnumType lhs, EnumType rhs) { return FlagSet<EnumType>(lhs) ^= rhs; }
 
} // end namespace iolink