BitMask.h

Go to the documentation of this file.

/*
 * BitMask.h
 *
 *  Created on: 13 Nov 2020
 *      Author: Valerio Formato
 */

#ifndef HERD_BITMASK_H_
#define HERD_BITMASK_H_

#include <bitset>
#include <string>
#include <type_traits>

#define ENABLE_BITMASK_OPERATORS(x)                                                                                    \
  template <> struct EnableBitMaskOperators<x> { static const bool enable = true; };

template <typename Enum> struct EnableBitMaskOperators { static const bool enable = false; };

template <typename Enum>
typename std::enable_if<EnableBitMaskOperators<Enum>::enable, Enum>::type operator|(const Enum lhs, const 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 operator&(const Enum lhs, const 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 operator^(const Enum lhs, const 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 operator~(const Enum rhs) {
  using underlying = typename std::underlying_type<Enum>::type;
  return static_cast<Enum>(~static_cast<underlying>(rhs));
}

template <typename Enum>
typename std::enable_if<EnableBitMaskOperators<Enum>::enable, Enum>::type operator!=(const Enum lhs, const 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 operator|=(Enum &lhs, const 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 operator&=(Enum &lhs, const 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 operator^=(Enum &lhs, const Enum rhs) {
  using underlying = typename std::underlying_type<Enum>::type;
  lhs = static_cast<Enum>(static_cast<underlying>(lhs) ^ static_cast<underlying>(rhs));
  return lhs;
}

// check if at least one bit from a pattern of ones and zeroes is present in bitmask
template <typename Enum>
typename std::enable_if<EnableBitMaskOperators<Enum>::enable, bool>::type
MatchAnyBit(const Enum test, const Enum ones, const Enum zeroes = static_cast<Enum>(0)) {
  return static_cast<bool>(test & ones) || static_cast<bool>((test ^ zeroes) & zeroes);
}

// check if a given pattern of ones and zeroes is present in bitmask
template <typename Enum>
typename std::enable_if<EnableBitMaskOperators<Enum>::enable, bool>::type
MatchAllBits(const Enum test, const Enum ones, const Enum zeroes = static_cast<Enum>(0)) {
  return (test & (ones | zeroes)) == ones;
}

// print this bitmask as a binary string
template <int N, typename Enum>
typename std::enable_if<EnableBitMaskOperators<Enum>::enable, std::string>::type to_string_binary(const Enum rhs) {
  return std::bitset<N>{static_cast<size_t>(rhs)}.to_string();
}

#endif