flags.h

Go to the documentation of this file.

#ifndef NNGN_FLAGS_H
#define NNGN_FLAGS_H
 
#include <type_traits>
#include <utility>
 
#include "concepts/fundamental.h"
#include "utils.h"
 
namespace nngn {
 
template<typename T>
struct Flags {
    using UT = std::underlying_type_t<T>;
    using AT = std::conditional_t<scoped_enum<T>, T, UT>;
    UT t = {};
    template<typename U> static constexpr Flags cast(U u);
    constexpr Flags(void) = default;
    constexpr Flags(UT u) : t{u} {}
    constexpr Flags(AT a) requires(scoped_enum<T>) : Flags{to_underlying(a)} {}
    constexpr bool is_set(AT a) const { return static_cast<bool>(*this & a); }
    constexpr Flags &flip() { return *this = ~*this; }
    constexpr Flags &set(AT a) { return *this |= a; }
    constexpr Flags &set(AT a, bool b);
    constexpr Flags &clear(AT a) { return *this &= ~Flags{a}; }
    constexpr Flags check_and_clear(AT a);
    constexpr explicit operator bool() const { return t; }
    constexpr Flags operator~() const { return Flags::cast(~this->t); }
    constexpr Flags operator-() const { return Flags::cast(-this->t); }
    constexpr Flags operator&(AT a) const;
    constexpr Flags operator|(AT a) const;
    constexpr Flags operator^(AT a) const;
    constexpr Flags &operator&=(AT a) { return *this = *this & Flags{a}; }
    constexpr Flags &operator|=(AT a) { return *this = *this | Flags{a}; }
    constexpr Flags &operator^=(AT a) { return *this = *this ^ Flags{a}; }
    constexpr Flags operator&(const Flags &f) const { return *this & f.t; }
    constexpr Flags operator|(const Flags &f) const { return *this | f.t; }
    constexpr Flags operator^(const Flags &f) const { return *this ^ f.t; }
    constexpr Flags &operator&=(const Flags &f) { return *this = *this & f.t; }
    constexpr Flags &operator|=(const Flags &f) { return *this = *this | f.t; }
    constexpr Flags &operator^=(const Flags &f) { return *this = *this ^ f.t; }
};
 
template<typename T>
template<typename U>
constexpr auto Flags<T>::cast(U u) -> Flags {
    return {static_cast<UT>(u)};
}
 
template<typename T>
constexpr auto Flags<T>::set(AT a, bool b) -> Flags& {
    return *this = Flags::cast(set_bit(this->t, a, b));
}
 
template<typename T>
constexpr auto Flags<T>::check_and_clear(AT a) -> Flags {
    return std::exchange(*this, *this & ~a) & a;
}
 
template<typename T>
constexpr auto Flags<T>::operator&(AT a) const -> Flags {
    return Flags::cast(this->t & static_cast<UT>(a));
}
 
template<typename T>
constexpr auto Flags<T>::operator|(AT a) const -> Flags {
    return Flags::cast(this->t | static_cast<UT>(a));
}
 
template<typename T>
constexpr auto Flags<T>::operator^(AT a) const -> Flags {
    return Flags::cast(this->t ^ static_cast<UT>(a));
}
 
}
 
#endif