Flags.h

Go to the documentation of this file.

#pragma once
 
 
#include "common/Assert.h"
#include "common/Traits.h"
#include "math/MathUtils.h"
 
NAMESPACE_SPH_BEGIN
 
struct EmptyFlags {};
 
const EmptyFlags EMPTY_FLAGS;
 
template <typename TEnum>
class Flags {
private:
    using TValue = std::underlying_type_t<TEnum>;
    TValue data = TValue(0);
 
public:
    constexpr Flags() = default;
 
    constexpr Flags(const Flags& other)
        : data(other.data) {}
 
    template <typename... TArgs>
    constexpr Flags(const TEnum flag, const TArgs... others)
        : data(construct(flag, others...)) {}
 
    constexpr Flags(const EmptyFlags) {}
 
    constexpr static Flags fromValue(const TValue value) {
        Flags flags;
        flags.data = value;
        return flags;
    }
 
    Flags& operator=(const Flags& other) {
        data = other.data;
        return *this;
    }
 
    Flags& operator=(const TEnum flag) {
        SPH_ASSERT(isPower2(TValue(flag)));
        data = TValue(flag);
        return *this;
    }
 
    Flags& operator=(const EmptyFlags) {
        data = TValue(0);
        return *this;
    }
 
    INLINE constexpr bool has(const TEnum flag) const {
        return (data & TValue(flag)) != 0;
    }
 
    template <typename... TArgs>
    INLINE constexpr bool hasAny(const TEnum flag, const TArgs... others) const {
        return has(flag) || hasAny(others...);
    }
 
    template <typename... TArgs>
    INLINE constexpr bool hasAll(const TEnum flag, const TArgs... others) const {
        return has(flag) && hasAll(others...);
    }
 
    INLINE void set(const TEnum flag) {
        SPH_ASSERT(isPower2(TValue(flag)));
        data |= TValue(flag);
    }
 
    INLINE void unset(const TEnum flag) {
        SPH_ASSERT(isPower2(TValue(flag)));
        data &= ~TValue(flag);
    }
 
    INLINE void setIf(const TEnum flag, const bool use) {
        SPH_ASSERT(isPower2(TValue(flag)));
        if (use) {
            data |= TValue(flag);
        } else {
            data &= ~TValue(flag);
        }
    }
 
    INLINE TValue value() const {
        return data;
    }
 
    INLINE constexpr Flags operator|(const TEnum flag) const {
        SPH_ASSERT(isPower2(TValue(flag)));
        Flags<TEnum> flags(*this);
        flags.set(flag);
        return flags;
    }
 
    INLINE bool operator==(const Flags& other) const {
        return data == other.data;
    }
 
    INLINE bool operator!=(const Flags& other) const {
        return data != other.data;
    }
 
private:
    // overload with no argument ending the recursion
    INLINE constexpr bool hasAny() const {
        return false;
    }
 
    INLINE constexpr bool hasAll() const {
        return true;
    }
 
    template <typename... TArgs>
    INLINE constexpr TValue construct(const TEnum first, const TArgs... rest) {
        SPH_ASSERT(TValue(first) == 0 || isPower2(TValue(first)));
        return TValue(first) | construct(rest...);
    }
 
    INLINE constexpr TValue construct() {
        return 0;
    }
};
 
template <typename TEnum, typename = std::enable_if_t<IsEnumClass<TEnum>::value>>
INLINE constexpr Flags<TEnum> operator|(const TEnum flag1, const TEnum flag2) {
    return Flags<TEnum>(flag1, flag2);
}
 
template <typename T>
struct FlagsTraits {
    static constexpr bool isFlags = false;
};
 
template <typename T>
struct FlagsTraits<Flags<T>> {
    static constexpr bool isFlags = true;
    using Type = T;
};
 
NAMESPACE_SPH_END