enumBitset.hpp

/*
 * CoDiPack, a Code Differentiation Package
 *
 * Copyright (C) 2015-2024 Chair for Scientific Computing (SciComp), University of Kaiserslautern-Landau
 * Homepage: http://www.scicomp.uni-kl.de
 * Contact:  Prof. Nicolas R. Gauger (codi@scicomp.uni-kl.de)
 *
 * Lead developers: Max Sagebaum, Johannes Blühdorn (SciComp, University of Kaiserslautern-Landau)
 *
 * This file is part of CoDiPack (http://www.scicomp.uni-kl.de/software/codi).
 *
 * CoDiPack is free software: you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * CoDiPack is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty
 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 *
 * See the GNU General Public License for more details.
 * You should have received a copy of the GNU
 * General Public License along with CoDiPack.
 * If not, see <http://www.gnu.org/licenses/>.
 *
 * For other licensing options please contact us.
 *
 * Authors:
 *  - SciComp, University of Kaiserslautern-Landau:
 *    - Max Sagebaum
 *    - Johannes Blühdorn
 *    - Former members:
 *      - Tim Albring
 */
#pragma once
 
#include <bitset>
#include <type_traits>
 
#include "../config.h"
#include "enumInterface.hpp"
#include "macros.hpp"
 
namespace codi {
 
  /* Original idea from http://stackoverflow.com/questions/17350214/using-enum-class-with-stdbitset */
 
  template<typename T_Enum>
  struct EnumBitset {
    public:
      using Enum = T_Enum;  
 
    private:
      using UnderlyingEnumType = typename std::underlying_type<Enum>::type;
      using Bitset = std::bitset<static_cast<UnderlyingEnumType>(Enum::MaxElement)>;
 
      static UnderlyingEnumType constexpr ALL_VALUE = (1 << static_cast<UnderlyingEnumType>(Enum::MaxElement)) - 1;
 
      Bitset bitset;
 
      CODI_INLINE UnderlyingEnumType get_value(Enum v) const {
        return static_cast<UnderlyingEnumType>(v);
      }
 
      CODI_INLINE EnumBitset(UnderlyingEnumType value) : bitset(value) {}
 
    public:
 
      CODI_INLINE EnumBitset() = default;
 
      CODI_INLINE EnumBitset(Enum pos) : bitset() {
        set(pos);
      }
 
      CODI_INLINE bool test(Enum pos) const {
        return bitset.test(get_value(pos));
      }
 
      CODI_INLINE EnumBitset& reset(Enum pos) {
        bitset.reset(get_value(pos));
        return *this;
      }
 
      CODI_INLINE EnumBitset& flip(Enum pos) {
        bitset.flip(get_value(pos));
        return *this;
      }
 
      CODI_INLINE EnumBitset& flip() {
        bitset.flip();
        bitset &= Bitset(ALL_VALUE);
        return *this;
      }
 
      CODI_INLINE EnumBitset& set(Enum pos) {
        bitset.set(get_value(pos));
        return *this;
      }
 
      CODI_INLINE EnumBitset& reset() {
        bitset.reset();
        return *this;
      }
 
      CODI_INLINE EnumBitset& operator|=(EnumBitset const& o) {
        bitset |= o.bitset;
        return *this;
      }
 
      CODI_INLINE EnumBitset& operator|=(Enum const& pos) {
        return set(pos);
      }
 
      CODI_INLINE EnumBitset& operator&=(EnumBitset const& o) {
        bitset &= o.bitset;
        return *this;
      }
 
      CODI_INLINE EnumBitset& operator&=(Enum const& pos) {
        return *this &= EnumBitset(pos);
      }
 
      CODI_INLINE bool operator!=(EnumBitset const& o) const {
        return bitset != o.bitset;
      }
 
      CODI_INLINE bool operator!=(Enum const& pos) const {
        return bitset != EnumBitset(pos).bitset;
      }
 
      CODI_INLINE bool operator==(EnumBitset const& o) const {
        return bitset == o.bitset;
      }
 
      CODI_INLINE bool operator==(Enum const& pos) const {
        return bitset == EnumBitset(pos).bitset;
      }
 
      CODI_INLINE bool any() {
        return this->bitset.any();
      }
 
      CODI_INLINE Bitset getData() const {
        return bitset;
      }
 
      CODI_INLINE static constexpr EnumBitset ALL() {
        return EnumBitset(ALL_VALUE);
      }
 
      CODI_INLINE static constexpr EnumBitset NONE() {
        return EnumBitset();
      }
  };
 
  template<typename Enum>
  CODI_INLINE EnumBitset<Enum> operator|(EnumBitset<Enum> const& a, EnumBitset<Enum> const& b) {
    EnumBitset<Enum> r = a;
    r |= b;
 
    return r;
  }
 
  template<typename Enum>
  CODI_INLINE EnumBitset<Enum> operator|(EnumBitset<Enum> const& a, Enum b) {
    EnumBitset<Enum> r = a;
    r |= b;
 
    return r;
  }
 
  template<typename Enum>
  CODI_INLINE EnumBitset<Enum> operator|(Enum a, EnumBitset<Enum> const& b) {
    return b | a;
  }
 
  template<typename Enum>
  CODI_INLINE EnumBitset<Enum> operator&(EnumBitset<Enum> const& a, EnumBitset<Enum> const& b) {
    EnumBitset<Enum> r = a;
    r &= b;
 
    return r;
  }
 
  template<typename Enum>
  CODI_INLINE EnumBitset<Enum> operator&(EnumBitset<Enum> const& a, Enum b) {
    EnumBitset<Enum> r = a;
    r &= b;
 
    return r;
  }
 
  template<typename Enum>
  CODI_INLINE EnumBitset<Enum> operator&(Enum a, EnumBitset<Enum> const& b) {
    return b & a;
  }
 
  template<typename Enum>
  CODI_INLINE bool operator!=(Enum a, EnumBitset<Enum> const& b) {
    return b != a;
  }
 
  template<typename Enum>
  CODI_INLINE bool operator==(Enum a, EnumBitset<Enum> const& b) {
    return b == a;
  }
 
  template<typename Out, typename Enum>
  CODI_INLINE Out& operator<<(Out& out, EnumBitset<Enum> const& b) {
    return out << b.getData();
  }
}