BitSet.h

Go to the documentation of this file.

/****
 * Sming Framework Project - Open Source framework for high efficiency native ESP8266 development.
 * Created 2015 by Skurydin Alexey
 * http://github.com/SmingHub/Sming
 * All files of the Sming Core are provided under the LGPL v3 license.
 *
 * BitSet.h - Strongly typed sets of values
 *
 * @author: 2020 - Mikee47 <mike@sillyhouse.net>
 *
 ****/
 
#pragma once
 
#include <cstddef>
#include <cstdint>
#include <limits>
#include <type_traits>
#include <WString.h>
#include <Print.h>
 
template <typename S, typename E, size_t size_ = sizeof(S) * 8> class BitSet
{
public:
    static_assert(std::is_integral<S>::value && std::is_unsigned<S>::value,
                  "BitSet requires an unsigned integral storage type");
    static_assert(std::is_enum<E>::value || (std::is_integral<E>::value && std::is_unsigned<E>::value),
                  "BitSets may use only enum or unsigned integral type elements");
    static_assert(size_ > 0, "BitSet size cannot be zero!");
    static_assert(size_ <= (sizeof(S) * 8), "BitSet has too many elements for storage type");
 
    class BitRef
    {
    public:
        operator bool() const
        {
            return bitset.test(e);
        }
 
        BitRef& operator=(bool b)
        {
            bitset.set(e, b);
            return *this;
        }
 
    private:
        friend BitSet;
        BitRef(BitSet& bitset, E e) : bitset(bitset), e(e)
        {
        }
 
        BitSet& bitset;
        E e;
    };
 
    constexpr BitSet() = default;
 
    template <typename S2> constexpr BitSet(const BitSet<S2, E>& bitset) : bitSetValue(bitset.value())
    {
    }
 
    constexpr BitSet(S value) : bitSetValue(value)
    {
    }
 
    constexpr BitSet(E e) : bitSetValue{bitVal(e)}
    {
    }
 
    bool operator==(const BitSet& other) const
    {
        return bitSetValue == other.bitSetValue;
    }
 
    bool operator!=(const BitSet& other) const
    {
        return bitSetValue != other.bitSetValue;
    }
 
    constexpr BitSet operator~() const
    {
        return BitSet(~bitSetValue & domain().bitSetValue);
    }
 
    static constexpr size_t size()
    {
        return size_;
    }
 
    static constexpr BitSet domain()
    {
        return std::numeric_limits<S>::max() >> ((sizeof(S) * 8) - size_);
    }
 
    static constexpr S bitVal(E e)
    {
        return S{1U} << unsigned(e);
    }
 
    BitSet& flip()
    {
        bitSetValue = ~bitSetValue & domain().bitSetValue;
        return *this;
    }
 
    BitSet& flip(E e)
    {
        bitSetValue ^= bitVal(e);
        return *this;
    }
 
    size_t count() const
    {
        return __builtin_popcount(bitSetValue);
    }
 
    BitSet& operator+=(const BitSet& rhs)
    {
        bitSetValue |= rhs.bitSetValue;
        return *this;
    }
 
    BitSet& operator-=(const BitSet& rhs)
    {
        bitSetValue &= ~rhs.bitSetValue;
        return *this;
    }
 
    BitSet& operator&=(const BitSet& rhs)
    {
        bitSetValue &= rhs.bitSetValue;
        return *this;
    }
 
    BitSet& operator|=(const BitSet& rhs)
    {
        bitSetValue |= rhs.bitSetValue;
        return *this;
    }
 
    BitSet& operator^=(const BitSet& rhs)
    {
        bitSetValue ^= rhs.bitSetValue;
        return *this;
    }
 
    bool test(E e) const
    {
        return (bitSetValue & bitVal(e)) != 0;
    }
 
    bool operator[](E e) const
    {
        return test(e);
    }
 
    BitRef operator[](E e)
    {
        return BitRef{*this, e};
    }
 
    bool any() const
    {
        return bitSetValue != 0;
    }
 
    bool any(const BitSet& other) const
    {
        return (bitSetValue & other.bitSetValue) != 0;
    }
 
    bool all() const
    {
        return bitSetValue == domain().bitSetValue;
    }
 
    bool none() const
    {
        return bitSetValue == S{0};
    }
 
    BitSet& set()
    {
        bitSetValue = domain().bitSetValue;
        return *this;
    }
 
    BitSet& set(E e, bool state = true)
    {
        if(state) {
            bitSetValue |= bitVal(e);
        } else {
            bitSetValue &= ~bitVal(e);
        }
        return *this;
    }
 
    BitSet& reset()
    {
        bitSetValue = S{0};
        return *this;
    }
 
    BitSet& reset(E e)
    {
        return set(e, false);
    }
 
    bool operator==(E e) const
    {
        return bitSetValue == bitVal(e);
    }
 
    explicit constexpr operator S() const
    {
        return bitSetValue;
    }
 
    constexpr S value() const
    {
        return bitSetValue;
    }
 
    /*
     * use a function pointer to allow for "if (s)" without the
     * complications of an operator bool(). for more information,
     * see: http://www.artima.com/cppsource/safebool.html
     */
    using IfHelperType = void (BitSet::*)() const;
 
    /*
     * Provides safe bool() operator
     * Evaluates as false if set is empty
     */
    operator IfHelperType() const
    {
        return any() ? &BitSet::IfHelper : 0;
    }
 
    size_t printTo(Print& p, const String& separator = ", ") const
    {
        extern String toString(E e);
 
        size_t n{0};
 
        for(unsigned i = 0; i < size(); ++i) {
            auto e = E(i);
            if(!test(e)) {
                continue;
            }
            if(n != 0) {
                n += p.print(separator);
            }
            n += p.print(e);
        }
 
        return n;
    }
 
private:
    void IfHelper() const
    {
    }
 
    S bitSetValue{0};
};
 
template <typename S, typename E, size_t size_>
inline constexpr BitSet<S, E, size_> operator&(const BitSet<S, E, size_>& x, const BitSet<S, E, size_>& y)
{
    return BitSet<S, E, size_>(S(x) & S(y));
}
 
template <typename S, typename E, size_t size_>
inline constexpr BitSet<S, E, size_> operator|(BitSet<S, E, size_> x, BitSet<S, E, size_> y)
{
    return BitSet<S, E, size_>(S(x) | S(y));
}
 
template <typename S, typename E, size_t size_>
inline constexpr BitSet<S, E, size_> operator|(BitSet<S, E, size_> x, E b)
{
    return x | BitSet<S, E, size_>(b);
}
 
template <typename S, typename E, size_t size_>
inline constexpr BitSet<S, E, size_> operator+(const BitSet<S, E, size_>& x, const BitSet<S, E, size_>& y)
{
    return x | y;
}
 
template <typename S, typename E, size_t size_>
inline constexpr BitSet<S, E, size_> operator-(const BitSet<S, E, size_>& x, const BitSet<S, E, size_>& y)
{
    return BitSet<S, E, size_>(S(x) & ~S(y));
}
 
template <typename S, typename E, size_t size_>
inline constexpr BitSet<S, E, size_> operator+(const BitSet<S, E, size_>& x, E b)
{
    return x | b;
}
 
template <typename S, typename E, size_t size_>
inline constexpr BitSet<S, E, size_> operator-(const BitSet<S, E, size_>& x, E b)
{
    return BitSet<S, E, size_>(S(x) & ~BitSet<S, E, size_>::bitVal(b));
}
 
template <typename S, typename E, size_t size_>
inline constexpr BitSet<S, E, size_> operator^(BitSet<S, E, size_> x, BitSet<S, E, size_> y)
{
    return BitSet<S, E, size_>(S(x) ^ S(y));
}
 
template <typename S, typename E, size_t size_>
inline constexpr BitSet<S, E, size_> operator^(BitSet<S, E, size_> x, E b)
{
    return x ^ BitSet<S, E, size_>(b);
}
 
/*
 * These allow construction of a maximally-sized BitSet in an expression,
 * which is then copy-constructed to the actual value. For example:
 *
 *      constexpr BitSet<uint8_t, Fruit> fixedBasket = Fruit::apple | Fruit::orange;
 *
 * `is_convertible` prevents match to regular enums or integral values, but allows enum class.
 *
 */
template <typename E>
constexpr
    typename std::enable_if<std::is_enum<E>::value && !std::is_convertible<E, int>::value, BitSet<uint32_t, E>>::type
    operator|(E a, E b)
{
    return BitSet<uint32_t, E>(BitSet<uint32_t, E>::bitVal(a) | BitSet<uint32_t, E>::bitVal(b));
}
 
template <typename E>
constexpr
    typename std::enable_if<std::is_enum<E>::value && !std::is_convertible<E, int>::value, BitSet<uint32_t, E>>::type
    operator+(E a, E b)
{
    return a | b;
}
 
template <typename T> typename std::enable_if<std::is_integral<T>::value, String>::type toString(T value)
{
    return String(value);
}
 
template <typename S, typename E, size_t size_>
String toString(const BitSet<S, E, size_>& bitset, const String& separator = ", ")
{
    extern String toString(E e);
 
    String s = String::empty;
 
    for(unsigned i = 0; i < bitset.size(); ++i) {
        if(!bitset[E(i)]) {
            continue;
        }
 
        if(s.length() != 0) {
            s += separator;
        }
        s += toString(E(i));
    }
 
    return s;
}
 
using BitSet32 = BitSet<uint32_t, uint8_t>;