bit_flags.hh

Go to the documentation of this file.

#ifndef DUNE_COPASI_COMMON_BITFLAGS_HH
#define DUNE_COPASI_COMMON_BITFLAGS_HH
 
#include <dune-copasi-config.hh>
 
#include <bitset>
#include <climits>
 
namespace Dune::Copasi {
 
template<class T>
struct is_bitflags : public std::is_enum<T>
{};
 
template<class T>
constexpr bool is_bitflags_v = is_bitflags<T>::value;
 
template<typename Enum>
class BitFlags
{
  // Ensure that Enum is a valid template
  static_assert(
    is_bitflags_v<Enum>,
    "Enum is not a bit flag and it should not be instantiated in BitFlag class");
  static_assert(std::is_enum_v<Enum>, "Emum type must be a enummeration type");
 
  using BitSet = std::bitset<CHAR_BIT * sizeof(Enum)>;
 
  using UnderlyingType = std::underlying_type_t<Enum>;
 
  static constexpr UnderlyingType null_value =
    UnderlyingType{} ^ UnderlyingType{};
 
public:
  static constexpr BitFlags<Enum> all_flags() { return
    BitFlags<Enum>{ static_cast<Enum>(~null_value) }; }
 
  static constexpr BitFlags<Enum> no_flags() {return
    BitFlags<Enum>{ static_cast<Enum>(null_value) }; }
 
  // All flags are default initialized to false
  constexpr inline BitFlags()
    : _value{ null_value }
  {}
 
  // Initialization with an underlying enumerator
  constexpr inline BitFlags(const Enum& value)
    : _value(static_cast<UnderlyingType>(value))
  {}
 
  // Initialization with a standard library bitset
  inline explicit BitFlags(const BitSet& bit_set)
    : BitFlags(static_cast<Enum>(bit_set.to_ullong()))
  {
    static_assert(sizeof(UnderlyingType) <= sizeof(unsigned long long),
                  "Underlying type is longer than maximum supported cast");
  }
 
  [[nodiscard]] constexpr inline BitSet as_bitset() const
  {
    return BitSet{ static_cast<unsigned long long>(_value) };
  }
  [[nodiscard]] constexpr inline UnderlyingType as_underlying() const { return _value; }
 
  constexpr inline UnderlyingType& as_underlying() { return _value; }
 
  [[nodiscard]] constexpr inline Enum as_enum() const { return static_cast<const Enum>(_value); }
 
  constexpr inline Enum& as_enum() { return static_cast<Enum&>(_value); }
 
  constexpr inline explicit operator Enum() const { return as_enum(); }
 
  constexpr inline BitFlags operator|(const BitFlags& rhs) const
  {
    return static_cast<Enum>(_value | rhs._value);
  }
 
  constexpr inline BitFlags operator&(const BitFlags& rhs) const
  {
    return static_cast<Enum>(_value & rhs._value);
  }
 
  constexpr inline BitFlags operator^(const BitFlags& rhs) const
  {
    return static_cast<Enum>(_value ^ rhs._value);
  }
 
  constexpr inline BitFlags operator<<(std::size_t pos) const
  {
    return static_cast<Enum>(_value << pos);
  }
 
  constexpr inline BitFlags operator>>(std::size_t pos) const
  {
    return static_cast<Enum>(_value >> pos);
  }
 
  inline BitFlags& operator|=(const BitFlags& rhs)
  {
    _value |= rhs._value;
    return *this;
  }
 
  inline BitFlags& operator&=(const BitFlags& rhs)
  {
    _value &= rhs._value;
    return *this;
  }
 
  inline BitFlags& operator^=(const BitFlags& rhs)
  {
    _value ^= rhs._value;
    return *this;
  }
 
  inline BitFlags& operator<<=(std::size_t pos)
  {
    _value <<= pos;
    return *this;
  }
 
  inline BitFlags& operator>>=(std::size_t pos)
  {
    _value >>= pos;
    return *this;
  }
 
  constexpr inline BitFlags operator~() const
  {
    return BitFlags{ static_cast<Enum>(~_value) };
  }
 
  [[nodiscard]] constexpr inline bool test(const BitFlags& flag) const
  {
    return (_value & flag._value) == flag._value;
  }
 
  inline void reset(const BitFlags& flag) { _value &= ~flag._value; }
 
  inline void set(const BitFlags& flag, bool value = true)
  {
    value ? (_value |= flag._value) : reset(flag);
  }
 
  inline void flip(const BitFlags& flag) { _value ^= flag; }
 
  [[nodiscard]] constexpr inline bool all() const { return as_bitset().all(); }
 
  [[nodiscard]] constexpr inline bool any() const { return as_bitset().any(); }
 
  [[nodiscard]] constexpr inline bool none() const { return as_bitset().none(); }
 
private:
  UnderlyingType _value;
};
 
template<class Enum>
constexpr inline std::enable_if_t<is_bitflags_v<Enum>, BitFlags<Enum>>
operator|(Enum lhs, Enum rhs)
{
  return BitFlags<Enum>{ lhs } | BitFlags<Enum>{ rhs };
}
 
template<class Enum>
constexpr inline std::enable_if_t<is_bitflags_v<Enum>, BitFlags<Enum>>
operator&(Enum lhs, Enum rhs)
{
  return BitFlags<Enum>{ lhs } & BitFlags<Enum>{ rhs };
}
 
template<class Enum>
constexpr inline std::enable_if_t<is_bitflags_v<Enum>, BitFlags<Enum>>
operator^(Enum lhs, Enum rhs)
{
  return BitFlags<Enum>{ lhs } ^ BitFlags<Enum>{ rhs };
}
 
template<class Enum>
constexpr inline std::enable_if_t<is_bitflags_v<Enum>, bool>
operator==(Enum lhs, Enum rhs)
{
  return BitFlags<Enum>{ lhs } == BitFlags<Enum>{ rhs };
}
 
template<class Enum>
constexpr inline std::enable_if_t<is_bitflags_v<Enum>, bool>
operator!=(Enum lhs, Enum rhs)
{
  return BitFlags<Enum>{ lhs } != BitFlags<Enum>{ rhs };
}
 
} // namespace Dune::Copasi
 
#endif // DUNE_COPASI_COMMON_BITFLAGS_HH