dyn_bitset.h

Go to the documentation of this file.

#pragma once

#include <cstdlib>
#include <exception>
#include <string>

class DynBitset {
    private:
        typedef long unsigned Word;

    public:
        class SizeMismatch : public std::exception {};

        class Reference {
            friend class DynBitset;
            public:
                Reference& operator=(bool);
                Reference& operator=(const Reference&);

                inline bool operator~() const {
                    return ~(*this);
                }

                inline operator bool() const {
                    return (*word) & (1lu << pos);
                }

                Reference& flip() {
                    (*word) ^= (1lu << pos);
                    return *this;
                }

                inline void set() {
                    (*word) |= (1lu << pos);
                }

                void reset() {
                    (*word) &= ~(1lu << pos);
                }

            private:
                Reference(DynBitset::Word* word, size_t pos)
                    : word(word), pos(pos) {}

                DynBitset::Word* word;
                size_t pos;
        };
        friend class Reference;

        // === Constructors and default operations ===

        DynBitset(size_t size);
        DynBitset(const DynBitset& oth);
        ~DynBitset();
        void operator=(const DynBitset& oth);
        DynBitset& operator=(DynBitset&& oth) = delete;
    private:
        DynBitset(size_t size, Word* words);
        DynBitset(DynBitset&& oth);

    public:
        // === Other methods ===

        inline size_t size() const { return size_; }

        inline bool operator[](size_t pos) const {
            return (data[pos/word_size]) & (1lu << (pos % word_size));
        }

        Reference operator[](size_t pos);

        DynBitset& operator &=(const DynBitset& oth);

        DynBitset& operator|=(const DynBitset& oth);

        DynBitset& operator^=(const DynBitset& oth);

        DynBitset& flip();

        DynBitset operator &(const DynBitset& oth) const;

        DynBitset operator|(const DynBitset& oth) const;

        DynBitset operator^(const DynBitset& oth) const;

        DynBitset operator~() const;

        void reset();

        bool any() const;

        bool anyOver(size_t pos) const;


        int singleBit() const;

        std::string dump() const;

    private:
        inline void checkSize(const DynBitset& oth) const {
            if(size_ != oth.size_)
                throw SizeMismatch();
        }

        inline size_t nbWords() const {
            return (size_ + word_size - 1) / word_size;
        }

        int whichBit(Word word, int offset = 0) const;

        const size_t size_;
        Word* data;

        constexpr static size_t word_size = sizeof(Word) * 8;
};