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 <string.h>
#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) {
                Word_t word = *store & -(1 << pos);
                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(0), 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 = 0;
    }

    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 = 0;
    }

    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 = 0;
        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 PhysicsTools

#endif // PhysicsTools_MVAComputer_BitSet_h