bitfield.h

// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
//
// In applying this license CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.

/// \file bitfield.h
/// \author David Rohr

#ifndef Q_BITFIELD_H
#define Q_BITFIELD_H

#if !defined(GPUCA_GPUCODE_DEVICE) && !defined(GPUCA_GPUCODE_COMPILEKERNELS)
#include <type_traits>
#endif

template <class T, class S>
class bitfield
{
 public:
  bitfield(T v) : bits((S)v) {}
  bitfield(S v = 0) : bits(v) {}
  bitfield(const bitfield&) = default;
  bitfield& operator=(const bitfield&) = default;
  bitfield operator|(const bitfield v) const { return bits | v.bits; }
  bitfield operator|(const T v) const { return bits | static_cast<S>(v); }
  bitfield& operator|=(const bitfield v)
  {
    bits |= v.bits;
    return *this;
  }
  bitfield operator&(const bitfield v) const { return bits & v.bits; }
  bitfield operator&(const T v) const { return bits & static_cast<S>(v); }
  bitfield& operator&=(const bitfield v)
  {
    bits &= v.bits;
    return *this;
  }
  bitfield operator~() const { return ~bits; }
  bool operator==(const bitfield v) { return bits == v.bits; }
  bool operator==(const T v) { return bits == static_cast<S>(v); }
  bool operator!=(const bitfield v) { return bits != v.bits; }
  bool operator!=(const T v) { return bits != static_cast<S>(v); }
  bitfield& setBits(const bitfield v, bool w)
  {
    if (w) {
      bits |= v.bits;
    } else {
      bits &= ~v.bits;
    }
    return *this;
  }
  void clear() { bits = 0; }
  void set(S v) { bits = v; }
  void set(T v) { bits = static_cast<S>(v); }
  template <typename... Args>
  void set(T v, Args... args)
  {
    this->set(args...);
    bits |= static_cast<S>(v);
  }
  S get() const { return bits; }
  operator bool() const { return bits; }
  operator S() const { return bits; }
  bool isSet(const bitfield& v) const { return *this & v; }
  bool isSet(const S v) const { return bits & v; }
  template <typename... Args>
  bool isSetAll(Args... args)
  {
    return (bits & lor(args...).bits) == lor(args...).bits;
  }
  template <typename... Args>
  bool isSetAny(Args... args)
  {
    return (bits & lor(args...).bits) != 0;
  }
  template <typename... Args>
  bool isOnlySet(Args... args)
  {
    return (bits & ~lor(args...).bits) == 0;
  }
  template <typename... Args>
  static bitfield lor(const Args&... args)
  {
    bitfield retVal;
    retVal.set(args...);
    return retVal;
  }

#if !defined(GPUCA_GPUCODE_DEVICE)
  static_assert(std::is_integral_v<S>, "Storage type non integral");
  static_assert(sizeof(S) >= sizeof(T), "Storage type has insufficient capacity");
#endif

 private:
  S bits;
};

#endif