flags.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
// Copyright 2026 Chris Leishman
 
#pragma once
 
#include <charconv>
#include <concepts>
#include <string>
#include <type_traits>
#include <utility>
 
namespace idfxx {
 
template<typename E>
inline constexpr bool enable_flags_operators = false;
 
template<typename E>
concept flag_enum = std::is_enum_v<E> && enable_flags_operators<E>;
 
template<flag_enum E>
class flags {
public:
    using enum_type = E;
 
    using underlying = std::underlying_type_t<E>;
 
    underlying bits{};
 
    constexpr explicit flags(underlying v) noexcept
        : bits(v) {}
    constexpr flags() noexcept = default;
 
    constexpr flags(E e) noexcept
        : bits(std::to_underlying(e)) {}
 
    [[nodiscard]] constexpr flags operator|(flags other) const noexcept {
        return flags{static_cast<underlying>(bits | other.bits)};
    }
 
    constexpr flags& operator|=(flags other) noexcept {
        bits |= other.bits;
        return *this;
    }
 
    [[nodiscard]] constexpr flags operator&(flags other) const noexcept {
        return flags{static_cast<underlying>(bits & other.bits)};
    }
 
    constexpr flags& operator&=(flags other) noexcept {
        bits &= other.bits;
        return *this;
    }
 
    [[nodiscard]] constexpr flags operator^(flags other) const noexcept {
        return flags{static_cast<underlying>(bits ^ other.bits)};
    }
 
    constexpr flags& operator^=(flags other) noexcept {
        bits ^= other.bits;
        return *this;
    }
 
    [[nodiscard]] constexpr flags operator-(flags other) const noexcept {
        return flags{static_cast<underlying>(bits & ~other.bits)};
    }
 
    constexpr flags& operator-=(flags other) noexcept {
        bits &= ~other.bits;
        return *this;
    }
 
    [[nodiscard]] constexpr flags operator~() const noexcept { return flags{static_cast<underlying>(~bits)}; }
 
    [[nodiscard]] constexpr bool contains(flags other) const noexcept {
        return other.bits != 0 && (bits & other.bits) == other.bits;
    }
 
    [[nodiscard]] constexpr bool contains_any(flags other) const noexcept { return (bits & other.bits) != 0; }
 
    [[nodiscard]] constexpr bool empty() const noexcept { return bits == 0; }
 
    [[nodiscard]] constexpr explicit operator bool() const noexcept { return bits != 0; }
 
    [[nodiscard]] constexpr bool operator==(flags const&) const noexcept = default;
 
    [[nodiscard]] constexpr bool operator==(E e) const noexcept { return bits == std::to_underlying(e); }
};
 
template<flag_enum E>
flags(E) -> flags<E>;
 
template<flag_enum E>
[[nodiscard]] constexpr auto to_underlying(flags<E> f) noexcept {
    return f.bits;
}
 
template<flag_enum E>
[[nodiscard]] inline std::string to_string(flags<E> f) {
    using underlying = typename flags<E>::underlying;
    char buf[2 + sizeof(underlying) * 2];
    buf[0] = '0';
    buf[1] = 'x';
    auto [ptr, ec] = std::to_chars(buf + 2, buf + sizeof(buf), to_underlying(f), 16);
    return std::string(buf, ptr);
}
 
} // namespace idfxx
 
// Free operators for flag enums, defined at global scope so that ADL finds them
// regardless of which namespace the enum is declared in. They are constrained by
// the flag_enum concept, so they only match opted-in enums.
 
template<idfxx::flag_enum E>
[[nodiscard]] constexpr idfxx::flags<E> operator|(E a, E b) noexcept {
    return idfxx::flags<E>{a} | idfxx::flags<E>{b};
}
 
template<idfxx::flag_enum E>
[[nodiscard]] constexpr idfxx::flags<E> operator&(E a, E b) noexcept {
    return idfxx::flags<E>{a} & idfxx::flags<E>{b};
}
 
template<idfxx::flag_enum E>
[[nodiscard]] constexpr idfxx::flags<E> operator^(E a, E b) noexcept {
    return idfxx::flags<E>{a} ^ idfxx::flags<E>{b};
}
 
template<idfxx::flag_enum E>
[[nodiscard]] constexpr idfxx::flags<E> operator~(E a) noexcept {
    return ~idfxx::flags<E>{a};
}
 
#include "sdkconfig.h"
#ifdef CONFIG_IDFXX_STD_FORMAT
#include <algorithm>
#include <format>
namespace std {
template<idfxx::flag_enum E>
struct formatter<idfxx::flags<E>> {
    constexpr auto parse(format_parse_context& ctx) { return ctx.begin(); }
 
    template<typename FormatContext>
    auto format(idfxx::flags<E> f, FormatContext& ctx) const {
        auto s = to_string(f);
        return std::copy(s.begin(), s.end(), ctx.out());
    }
};
} // namespace std
#endif // CONFIG_IDFXX_STD_FORMAT