BitSet.h

Go to the documentation of this file.

#ifndef PhysicsTools_MVAComputer_BitSet_h
#define PhysicsTools_MVAComputer_BitSet_h
// -*- C++ -*-
//
// Package:     MVAComputer
// Class  :     BitSet
//

//
// Author:  Christophe Saout <christophe.saout@cern.ch>
// Created:     Sat Apr 24 15:18 CEST 2007
//

#include <cstring>
#include <cstddef>
#include <cstring>

namespace PhysicsTools {

  class BitSet {
  public:
    typedef std::size_t size_t;

  protected:
    typedef unsigned int Word_t;

  public:
    struct Manipulator {
    public:
      inline Manipulator(const Manipulator &orig) : word(orig.word), mask(orig.mask) {}
      inline ~Manipulator() {}

      inline operator bool() const { return *word & mask; }

      inline bool operator=(bool bit) {
        *word = (*word & ~mask) | (bit ? mask : 0);
        return bit;
      }

    protected:
      friend class BitSet;

      inline Manipulator(Word_t *word, unsigned int bit) : word(word), mask((Word_t)1 << bit) {}

    private:
      Word_t *word;
      Word_t mask;
    };

    struct Iterator {
    public:
      inline operator bool() const { return store < end; }

      inline size_t operator()() const { return (store - begin) * wordSize + pos; }

      Iterator &operator++() {
        if (++pos < wordSize) {
          //Only look at bits at and beyond pos
          Word_t word = *store & ((~(1U << pos)) + 1);
          if (word) {
            pos = ffs(word) - 1;
            return *this;
          }
        }

        pos = 0;
        for (;;) {
          if (++store >= end)
            break;
          else if (*store) {
            pos = ffs(*store) - 1;
            break;
          }
        }

        return *this;
      }

      inline Iterator operator++(int dummy) {
        Iterator orig = *this;
        ++*this;
        return orig;
      }

    protected:
      friend class BitSet;

      Iterator(Word_t *begin, Word_t *end) : begin(begin), store(begin), end(end), pos(0) {
        if (store < end && !(*store & 1))
          ++*this;
      }

    private:
      Word_t *begin, *store, *end;
      unsigned int pos;
    };

    BitSet() : store(nullptr), bits_(0) {}

    BitSet(const BitSet &orig) : bits_(orig.bits_) {
      std::size_t words = bitsToWords(bits_);
      if (words) {
        store = new Word_t[words];
        std::memcpy(store, orig.store, words * sizeof(Word_t));
      } else
        store = nullptr;
    }

    BitSet(size_t bits) : bits_(bits) {
      std::size_t words = bitsToWords(bits);
      if (words) {
        store = new Word_t[words];
        std::memset(store, 0, sizeof(Word_t) * words);
      } else
        store = nullptr;
    }

    inline ~BitSet() { delete[] store; }

    BitSet &operator=(const BitSet &orig) {
      delete[] store;
      bits_ = orig.bits_;
      std::size_t words = bitsToWords(bits_);
      if (words) {
        store = new Word_t[words];
        std::memcpy(store, orig.store, words * sizeof(Word_t));
      } else
        store = nullptr;
      return *this;
    }

    inline Manipulator operator[](size_t bit) { return Manipulator(&store[bit / wordSize], bit % wordSize); }

    inline const Manipulator operator[](size_t bit) const {
      return Manipulator(&store[bit / wordSize], bit % wordSize);
    }

    inline size_t size() const { return bits_; }

    size_t bits() const;

    inline Iterator iter() const { return Iterator(store, store + bitsToWords(bits_)); }

  private:
    static inline size_t bitsToWords(std::size_t bits) { return (bits + wordSize - 1) / wordSize; }

    static const unsigned int wordSize = sizeof(Word_t) * 8;

    Word_t *store;
    size_t bits_;
  };

  namespace Calibration {
    class BitSet;

    PhysicsTools::BitSet convert(const BitSet &bitSet);
    BitSet convert(const PhysicsTools::BitSet &bitSet);
  }  // namespace Calibration

}  // namespace PhysicsTools

#endif  // PhysicsTools_MVAComputer_BitSet_h