BitMask.hxx

#pragma once
 
// C++
#include <initializer_list>
#include <string>
#include <type_traits>
 
namespace cosmos {
 
 
template <typename ENUM>
class BitMask {
public: // types
 
        struct All {};
        static constexpr All all{};
 
        using EnumBaseType = typename std::underlying_type<ENUM>::type;
 
public: // functions
 
        constexpr BitMask() {}
 
        explicit BitMask(const All a) {
                set(a);
        }
        explicit BitMask(const All a) {…}
 
        constexpr BitMask(const std::initializer_list<ENUM> &init_list) {
                for (auto val: init_list) {
                        m_flags |= static_cast<EnumBaseType>(val);
                }
        }
        constexpr BitMask(const std::initializer_list<ENUM> &init_list) {…}
 
        explicit constexpr BitMask(const ENUM val) :
                m_flags{static_cast<EnumBaseType>(val)}
        {}
        explicit constexpr BitMask(const ENUM val) : {…}
 
        explicit constexpr BitMask(const EnumBaseType value) :
                m_flags{value}
        {}
        explicit constexpr BitMask(const EnumBaseType value) : {…}
 
        EnumBaseType raw() const { return m_flags; }
 
        explicit operator std::string() const { return toString(); }
 
        bool operator[] (const ENUM flag) const { return test(flag); }
 
        std::string toString() const {
                std::string ret;
 
                // append each bit starting with the highest one
                for (int bit = size() - 1; bit >= 0; bit--) {
                        const auto val = 1 << bit;
                        ret.push_back(this->test(static_cast<ENUM>(val)) ? '1' : '0');
                }
 
                return ret;
        }
 
        BitMask& set(const All) {
                m_flags = ~EnumBaseType(0);
                return *this;
        }
        BitMask& set(const All) {…}
 
        BitMask& set(const ENUM val, bool on_off = true) {
                const auto bitval = static_cast<EnumBaseType>(val);
                m_flags = (on_off ? (m_flags|bitval) : (m_flags & ~bitval));
                return *this;
        }
        BitMask& set(const ENUM val, bool on_off = true) {…}
 
        BitMask& set(const std::initializer_list<ENUM> &flags) {
                for (auto flag: flags) {
                        set(flag);
                }
                return *this;
        }
 
        BitMask& set(const BitMask other) {
                m_flags |= other.m_flags;
                return *this;
        }
        BitMask& set(const BitMask other) {…}
 
        BitMask& reset() {
                m_flags = EnumBaseType{0};
                return *this;
        }
        BitMask& reset() {…}
 
        BitMask& reset(const ENUM val) {
                reset({val});
                return *this;
        }
        BitMask& reset(const ENUM val) {…}
 
        BitMask& reset(const std::initializer_list<ENUM> &flags) {
                for (auto val: flags) {
                        m_flags &= ~static_cast<EnumBaseType>(val);
                }
                return *this;
        }
        BitMask& reset(const std::initializer_list<ENUM> &flags) {…}
 
        BitMask& reset(const BitMask other) {
                m_flags &= ~(other.raw());
                return *this;
        }
 
        BitMask reset(const BitMask other) const {
                auto ret = *this;
                return ret.reset(other);
        }
 
        BitMask& limit(const std::initializer_list<ENUM> &flags) {
                EnumBaseType mask = 0;
                for (auto val: flags) {
                        mask |= static_cast<EnumBaseType>(val);
                }
 
                m_flags &= mask;
                return *this;
        }
        BitMask& limit(const std::initializer_list<ENUM> &flags) {…}
 
        BitMask& limit(const ENUM flag) {
                return limit({flag});
        }
        BitMask& limit(const ENUM flag) {…}
 
        BitMask& limit(const BitMask other) {
                m_flags &= other.raw();
                return *this;
        }
        BitMask& limit(const BitMask other) {…}
 
        BitMask limit(const BitMask other) const {
                auto ret = *this;
                return ret.limit(other);
        }
 
        BitMask& flip() {
                m_flags = ~m_flags;
                return *this;
        }
        BitMask& flip() {…}
 
        BitMask& flip(const ENUM val) {
                m_flags ^= static_cast<EnumBaseType>(val);
                return *this;
        }
        BitMask& flip(const ENUM val) {…}
 
        size_t count() const {
                size_t ret = 0;
 
                for (size_t bit = 0; bit < size(); bit++) {
                        auto val = 1 << bit;
                        if (this->test(static_cast<ENUM>(val)))
                                ret++;
                }
 
                return ret;
        }
        size_t count() const  {…}
 
        constexpr size_t size() const {
                return sizeof(EnumBaseType) * 8;
        }
        constexpr size_t size() const  {…}
 
 
        bool test(const ENUM val) const {
                const auto raw_val = static_cast<EnumBaseType>(val);
                return (m_flags & raw_val) == raw_val;
        }
        bool test(const ENUM val) const  {…}
 
 
        bool testAny(const ENUM val) const {
                return ((m_flags & static_cast<EnumBaseType>(val)) != 0);
        }
        bool testAny(const ENUM val) const  {…}
 
 
        bool only(const ENUM val) const {
                return m_flags == static_cast<EnumBaseType>(val);
        }
        bool only(const ENUM val) const  {…}
 
        bool any() const {
                return m_flags != 0;
        }
        bool any() const  {…}
 
        bool allOf(const std::initializer_list<ENUM> &flags) const {
                for (auto val: flags) {
                        if (!test(val))
                                return false;
                }
 
                return true;
        }
        bool allOf(const std::initializer_list<ENUM> &flags) const  {…}
 
        bool allOf(const BitMask other) const {
                return (m_flags & other.m_flags) == other.m_flags;
        }
 
        bool anyOf(const std::initializer_list<ENUM> &flags) const {
                for (auto val: flags) {
                        if (test(val))
                                return true;
                }
 
                return false;
        }
        bool anyOf(const std::initializer_list<ENUM> &flags) const  {…}
 
        bool anyOf(const BitMask other) const {
                return (m_flags & other.m_flags) != 0;
        }
 
        bool none() const {
                return !this->any();
        }
        bool none() const  {…}
 
        bool operator==(const BitMask &other) const {
                return m_flags == other.m_flags;
        }
 
        bool operator!=(const BitMask &other) const {
                return !(*this == other);
        }
 
        bool operator&(const ENUM val) const {
                return testAny(val);
        }
        bool operator&(const ENUM val) const  {…}
 
        ENUM operator&(const BitMask &other) const {
                return ENUM{other.raw() & this->raw()};
        }
        ENUM operator&(const BitMask &other) const  {…}
 
        BitMask operator~() const {
                return BitMask{~m_flags};
        }
 
        friend BitMask operator-(const BitMask &first, const BitMask &second) {
                BitMask ret{first};
                return ret.reset(second);
        }
        friend BitMask operator-(const BitMask &first, const BitMask &second) {…};
 
        friend BitMask operator-(const BitMask &first, const ENUM val) {
                BitMask ret{first};
                return ret.reset(val);
        }
        friend BitMask operator-(const BitMask &first, const ENUM val) {…};
 
        friend BitMask operator+(const BitMask &first, const BitMask &second) {
                BitMask ret{first};
                return ret.set(second);
        }
        friend BitMask operator+(const BitMask &first, const BitMask &second) {…};
 
        friend BitMask operator+(const BitMask &first, const ENUM val) {
                BitMask ret{first};
                return ret.set(val);
        }
        friend BitMask operator+(const BitMask &first, const ENUM val) {…};
 
protected: // data
 
        EnumBaseType m_flags = 0;
};
class BitMask {…};
 
} // end ns