bitmask.h

Go to the documentation of this file.

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

#ifndef NAIA_BITMASK_H_
#define NAIA_BITMASK_H_

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

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

namespace NAIA {

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();
}

} // namespace NAIA

#endif