Flags.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "CeresEngine/DataTypes.hpp"
#include "CeresEngine/Foundation/Hash.hpp"
 
#include <utility>
 
namespace CeresEngine {
 
    template<typename Enum, typename Storage = std::underlying_type_t<Enum>> struct Flags {
        Storage raw = 0;
 
        constexpr Flags() noexcept = default;
 
        constexpr Flags(Enum value) noexcept // NOLINT
                : raw(static_cast<Storage>(value)) {}
 
        constexpr Flags& operator=(Enum value) noexcept {
            raw = static_cast<Storage>(value);
            return *this;
        }
 
        constexpr Flags(const std::initializer_list<Enum>& values) noexcept {
            for(Enum value : values) {
                set(value);
            }
        }
 
        constexpr Flags(const Flags& value) noexcept : raw(value.raw) {}
        constexpr Flags& operator=(const Flags& rhs) noexcept {
            raw = rhs.raw;
            return *this;
        }
 
        explicit constexpr Flags(Storage bits) noexcept : raw(bits) {}
 
        [[nodiscard]] constexpr bool isSet(Enum value) const noexcept {
            return (raw & static_cast<Storage>(value)) == static_cast<Storage>(value); // NOLINT
        }
 
        [[nodiscard]] constexpr bool isSet(const Flags& value) const noexcept {
            return (raw & value.raw) == value.raw; // NOLINT
        }
 
        [[nodiscard]] constexpr bool isSetAny(Enum value) const noexcept {
            return (raw & static_cast<Storage>(value)) != 0; // NOLINT
        }
 
        [[nodiscard]] constexpr bool isSetAny(const Flags& value) const noexcept {
            return (raw & value.raw) != 0; // NOLINT
        }
 
        constexpr Flags& set(Enum value) noexcept {
            raw |= static_cast<Storage>(value); // NOLINT
            return *this;
        }
 
        constexpr Flags& set(Enum value, const bool state) noexcept {
            if(state) {
                set(value);
            } else {
                unset(value);
            }
            return *this;
        }
 
        constexpr Flags& unset(Enum value) noexcept {
            raw &= ~static_cast<Storage>(value); // NOLINT
            return *this;
        }
 
        constexpr Flags& unset(const Flags<Enum> value) noexcept {
            raw &= ~static_cast<Storage>(value.raw); // NOLINT
            return *this;
        }
 
        constexpr bool setIfUnset(Enum value) noexcept {
            if(isSet(value)) {
                return false;
            }
 
            set(value);
            return true;
        }
 
        constexpr bool unsetIfSet(Enum value) noexcept {
            if(!isSet(value)) {
                return false;
            }
 
            unset(value);
            return true;
        }
 
        constexpr bool operator==(Enum rhs) const noexcept { return raw == static_cast<Storage>(rhs); }
        constexpr bool operator==(const Flags& rhs) const noexcept { return raw == rhs.raw; }
        constexpr bool operator==(const bool rhs) const noexcept { return ((bool)*this) == rhs; }
 
        constexpr bool operator!=(Enum rhs) const noexcept { return raw != static_cast<Storage>(rhs); }
        constexpr bool operator!=(const Flags& rhs) const noexcept { return raw != rhs.raw; }
 
        constexpr Flags& operator|=(Enum rhs) noexcept {
            raw |= static_cast<Storage>(rhs); // NOLINT
            return *this;
        }
 
        constexpr Flags& operator|=(const Flags& rhs) noexcept {
            raw |= rhs.raw; // NOLINT
            return *this;
        }
 
        constexpr Flags operator|(Enum rhs) const noexcept {
            Flags out(*this);
            out |= rhs; // NOLINT
            return out;
        }
 
        constexpr Flags operator|(const Flags& rhs) const noexcept {
            Flags out(*this);
            out |= rhs; // NOLINT
            return out;
        }
 
        constexpr Flags& operator&=(Enum rhs) noexcept {
            raw &= static_cast<Storage>(rhs); // NOLINT
            return *this;
        }
 
        constexpr Flags& operator&=(const Flags& rhs) noexcept {
            raw &= rhs.raw; // NOLINT
            return *this;
        }
 
        constexpr Flags operator&(Enum rhs) const noexcept {
            Flags out = *this;
            out.raw &= static_cast<Storage>(rhs); // NOLINT
            return out;
        }
 
        constexpr Flags operator&(const Flags& rhs) const noexcept {
            Flags out = *this;
            out.raw &= rhs.raw; // NOLINT
            return out;
        }
 
        constexpr Flags& operator^=(Enum rhs) noexcept {
            raw ^= static_cast<Storage>(rhs); // NOLINT
            return *this;
        }
 
        constexpr Flags& operator^=(const Flags& rhs) noexcept {
            raw ^= rhs.raw; // NOLINT
            return *this;
        }
 
        constexpr Flags operator^(Enum rhs) const noexcept {
            Flags out = *this;
            out.raw ^= static_cast<Storage>(rhs); // NOLINT
            return out;
        }
 
        constexpr Flags operator^(const Flags& rhs) const noexcept {
            Flags out = *this;
            out.raw ^= rhs.raw; // NOLINT
            return out;
        }
 
        constexpr Flags operator~() const noexcept {
            Flags out;
            out.raw = (Storage)~raw; // NOLINT
            return out;
        }
 
        explicit constexpr operator Enum() const noexcept { return static_cast<Enum>(raw); }
        explicit constexpr operator Storage() const noexcept { return static_cast<UInt8>(raw); }
        explicit constexpr operator bool() const noexcept { return raw ? true : false; }
 
        friend constexpr Flags operator&(Enum a, Flags& b) noexcept {
            Flags out;
            out.raw = a & b.raw;
            return out;
        }
    };
 
#define CE_FLAGS_OPERATORS(Enum) CE_FLAGS_OPERATORS_EXT(Enum, std::underlying_type_t<Enum>)
 
#define CE_FLAGS_OPERATORS_EXT(Enum, Storage)                                                \
    [[nodiscard]] inline constexpr Flags<Enum, Storage> operator|(Enum a, Enum b) noexcept { \
        Flags<Enum, Storage> r(a);                                                           \
        r |= b; /* NOLINT */                                                                 \
        return r;                                                                            \
    }                                                                                        \
                                                                                             \
    [[nodiscard]] inline constexpr Flags<Enum, Storage> operator&(Enum a, Enum b) noexcept { \
        Flags<Enum, Storage> r(a);                                                           \
        r &= b; /* NOLINT */                                                                 \
        return r;                                                                            \
    }                                                                                        \
                                                                                             \
    [[nodiscard]] inline constexpr Flags<Enum, Storage> operator~(Enum a) noexcept { return ~Flags<Enum, Storage>(a); }
 
    // Common flags class.
    class RawFlags {
    public:
        unsigned int raw = 0;
 
        RawFlags() = default;
        RawFlags(const RawFlags&) = default;
        RawFlags& operator=(const RawFlags&) = default;
 
        // Initializes the object with the specified flags.
        inline RawFlags(const unsigned int flags) : raw{flags} {}
 
        // Sets the specified flag only once and returns true if the flag has not already been set.
        inline bool setOnce(const unsigned int flag) {
            if(!all(flag)) {
                *this << flag;
                return true;
            }
            return false;
        }
 
        // Sets the specified flag.
        inline void insert(const unsigned int flag) { raw |= flag; }
 
        // Removes the specified flag.
        inline void remove(const unsigned int flag) { raw &= (~flag); }
 
        // Sets the specified flag (see 'Insert' function).
        inline RawFlags& operator<<(const unsigned int flag) {
            insert(flag);
            return *this;
        }
 
        // Returns true if this flags instance has any of the specified flags.
        [[nodiscard]] inline bool any(const unsigned int flags) const { return ((raw & flags) != 0); }
 
        // Returns true if this flags instance has all of the specified flags.
        [[nodiscard]] inline bool all(const unsigned int flags) const { return ((raw & flags) == flags); }
 
        // Returns true if the specified flag is set.
        inline bool operator()(const unsigned int flag) const { return any(flag); }
 
        // Returns the flags bit mask.
        inline operator unsigned int() const { return raw; }
    };
 
} // namespace CeresEngine
 
template<class Enum, class Storage> struct std::hash<CeresEngine::Flags<Enum, Storage>> {
    size_t operator()(const CeresEngine::Flags<Enum, Storage>& key) const {
        std::hash<Storage> hasher{};
        return hasher(key.raw);
    }
};