BitFlags.hpp

Go to the documentation of this file.

/*
 * This file is part of the DUDS project. It is subject to the BSD-style
 * license terms in the LICENSE file found in the top-level directory of this
 * distribution and at https://github.com/jjackowski/duds/blob/master/LICENSE.
 * No part of DUDS, including this file, may be copied, modified, propagated,
 * or distributed except according to the terms contained in the LICENSE file.
 *
 * Copyright (C) 2017  Jeff Jackowski
 */
#ifndef BITFLAGS_HPP
#define BITFLAGS_HPP

#include <functional>

namespace duds { namespace general {

template <class Tag, class BitsType = int>
class BitFlags {
    BitsType bits;
    public:
    typedef BitsType bitsType;
    BitFlags() = default;
    constexpr BitFlags(const BitsType &b) : bits(b) { }
    constexpr BitFlags(const BitFlags &f) : bits(f.bits) { }
    static constexpr BitFlags Zero() {
        return BitFlags((BitsType)0);
    }
    static constexpr BitFlags Bit(BitsType b) {
        return BitFlags(((BitsType)1) << b);
    }
    constexpr BitsType flags() const {
        return bits;
    }
    constexpr BitFlags operator | (const BitFlags &bf) const {
        return bits | bf.bits;
    }
    BitFlags operator |= (const BitFlags &bf) {
        return bits |= bf.bits;
    }
    constexpr BitFlags operator & (const BitFlags &bf) const {
        return bits & bf.bits;
    }
    BitFlags operator &= (const BitFlags &bf) {
        return bits &= bf.bits;
    }
    constexpr BitFlags operator ^ (const BitFlags &bf) const {
        return bits ^ bf.bits;
    }
    BitFlags operator ^= (const BitFlags &bf) {
        return bits ^= bf.bits;
    }
    constexpr bool operator == (const BitFlags &bf) const {
        return bits == bf.bits;
    }
    constexpr bool operator != (const BitFlags &bf) const {
        return bits != bf.bits;
    }
    constexpr bool operator == (const BitsType &b) const {
        return bits == b;
    }
    constexpr bool operator != (const BitsType &b) const {
        return bits != b;
    }
    constexpr BitFlags operator ~ () const {
        return ~bits;
    }
    constexpr bool operator ! () const {
        return !bits;
    }
    constexpr operator bool () const {
        return bits != 0;
    }
    BitFlags operator = (const BitFlags &bf) {
        return bits = bf.bits;
    }
    BitFlags mask(const BitFlags &mask) {
        return bits &= mask.bits;
    }
    BitFlags clear() {
        return bits = 0;
    }
    BitFlags clear(const BitFlags &bf) {
        return bits &= ~bf.bits;
    }
    BitFlags set(const BitFlags &bf) {
        return bits |= bf.bits;
    }
    BitFlags setTo(const BitFlags &bf, bool val) {
        if (val) {
            return bits |= bf.bits;
        }
        return bits &= ~bf.bits;
    }
    BitFlags setMasked(const BitFlags &bf, const BitFlags &mask) {
        return bits = (bits & (~mask.bits)) | (bf.bits & mask.bits);
    }
    BitFlags toggle(const BitFlags &bf) {
        return bits ^= bf.bits;
    }
    constexpr bool test(const BitFlags &value, const BitFlags &mask) const {
        return (bits & mask.bits) == (value.bits & mask.bits);
    }
    constexpr bool test(const BitFlags &valuemask) const {
        return (bits & valuemask.bits) == valuemask.bits;
    }
};

} } // namespaces

namespace std {

template <class T, class B>
struct hash< duds::general::BitFlags<T, B> > {
    std::size_t operator()(const duds::general::BitFlags<T, B> &bf) const {
        return hash<B>()(bf.flags());
    }
};

}

namespace duds { namespace general {

template <class T, class B>
inline std::size_t hash_value(const duds::general::BitFlags<T, B> &bf) {
    return std::hash< duds::general::BitFlags<T, B> >()(bf);
}

} }

#endif        //  #ifndef BITFLAGS_HPP