Sawyer/BitFlags.h

// WARNING: Changes to this file must be contributed back to Sawyer or else they will
//          be clobbered by the next update from Sawyer.  The Sawyer repository is at
//          https://github.com/matzke1/sawyer.




#ifndef Sawyer_BitFlags_H
#define Sawyer_BitFlags_H

#include <Sawyer/Sawyer.h>

#include <boost/foreach.hpp>
#include <boost/serialization/access.hpp>
#include <Sawyer/Assert.h>
#include <vector>

namespace Sawyer {

template<typename E, typename V = int64_t>
class BitFlags {
public:
    typedef E Enum;
    typedef V Vector;

private:
    Vector vector_;

private:
    friend class boost::serialization::access;

    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        s & BOOST_SERIALIZATION_NVP(vector_);
    }

public:
    BitFlags()
        : vector_(0) {}

    BitFlags(Vector v) /*implicit*/
        : vector_(v) {}

    BitFlags(E e) /*implicit*/
        : vector_(Vector(e)) {}

    Vector vector() const {
        return vector_;
    }

    bool isSet(Enum e) const {
        return (vector_ & Vector(e)) != 0;
    }

    bool isAllSet(BitFlags other) const {
        return (vector_ & other.vector_) == other.vector_;
    }

    bool isAnySet(BitFlags other) const {
        return (vector_ & other.vector_) != 0;
    }

    bool isAnySet() const {
        return vector_ != 0;
    }

    bool isEmpty() const {
        return 0 == vector_;
    }

    bool isClear(Enum e) const {
        return !isSet(e);
    }

    BitFlags& set(Enum e) {
        vector_ |= Vector(e);
        return *this;
    }

    BitFlags& set(BitFlags other) {
        vector_ |= other.vector_;
        return *this;
    }

    BitFlags& clear(Enum e) {
        vector_ &= ~Vector(e);
        return *this;
    }

    BitFlags& clear(BitFlags other) {
        vector_ &= ~other.vector_;
        return *this;
    }

    BitFlags& clear() {
        vector_ = Vector(0);
        return *this;
    }

    bool testAndClear(Enum e) {
        bool retval = isSet(e);
        clear(e);
        return retval;
    }

    bool testAndSet(Enum e) {
        bool retval = isSet(e);
        set(e);
        return retval;
    }

    BitFlags& operator=(Vector v) {
        vector_ = v;
        return *this;
    }

    BitFlags& operator=(BitFlags other) {
        vector_ = other.vector_;
        return *this;
    }

    BitFlags operator|(BitFlags other) const {
        return vector_ | other.vector_;
    }
    BitFlags operator|(Enum e) const {
        return vector_ | Vector(e);
    }
    BitFlags intersection(BitFlags other) const {
        return vector_ & other.vector_;
    }
    BitFlags intersection(Enum e) const {
        return vector_ & Vector(e);
    }
    BitFlags operator&(BitFlags other) const {
        return intersection(other);
    }
    BitFlags operator&(Enum e) const {
        return intersection(e);
    }
    bool operator==(BitFlags other) const {
        return vector_ == other.vector_;
    }
    bool operator!=(BitFlags other) const {
        return vector_ != other.vector_;
    }
    bool operator<(BitFlags other) const {
        return vector_ < other.vector_;
    }
    bool operator<=(BitFlags other) const {
        return vector_ <= other.vector_;
    }
    bool operator>(BitFlags other) const {
        return vector_ > other.vector_;
    }
    bool operator>=(BitFlags other) const {
        return vector_ >= other.vector_;
    }
    std::vector<Enum> split(std::vector<int64_t> constants, Vector &leftovers /*out*/) const {
        leftovers = Vector(0);
        std::vector<Enum> retval;
        std::sort(constants.begin(), constants.end(), moreBits);
        Vector tmp = vector_;
        while (tmp) {
            bool found = false;
            for (size_t i=0; i<constants.size() && !found; ++i) {
                if (Vector(tmp & constants[i]) == Vector(constants[i]) && constants[i] != 0) {
                    retval.push_back(Enum(constants[i]));
                    tmp &= ~constants[i];
                    found = true;
                }
            }
            if (!found) {
                leftovers = tmp;
                tmp = 0;
            }
        }
        return retval;
    }

    std::vector<Enum> split(Vector &leftovers /*out*/) const {
        std::vector<Enum> retval;
        for (size_t i = 0; i < 8*sizeof(Enum); ++i) {
            Enum e = static_cast<Enum>(uint64_t(1) << i);
            if (isSet(e))
                retval.push_back(e);
        }
        return retval;
    }

#if __cplusplus >= 201103L

    template<class F>
    void each(std::vector<int64_t> constants, const F &functor) const {
        Vector leftovers;
        for (Enum e: split(constants, leftovers))
            functor(e);
    }

    template<class F>
    void each(const F &functor) const {
        Vector leftovers;
        for (Enum e: split(leftovers))
            functor(e);
    }
#endif

private:
    static size_t nBits(Vector vector) {
        size_t retval = 0;
        for (size_t i = 0; i < 8*sizeof(Vector); ++i) {
            if ((vector & (Vector(1) << i)) != 0)
                ++retval;
        }
        return retval;
    }

    static bool moreBits(Vector a, Vector b) {
        return nBits(a) > nBits(b);
    }
};

} // namespace
#endif