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>;
 
private:
    underlying value_{};
 
    constexpr explicit flags(underlying v) noexcept
        : value_(v) {}
public:
    constexpr flags() noexcept = default;
 
    constexpr flags(E e) noexcept
        : value_(std::to_underlying(e)) {}
 
    [[nodiscard]] constexpr flags operator|(flags other) const noexcept { return flags{value_ | other.value_}; }
 
    constexpr flags& operator|=(flags other) noexcept {
        value_ |= other.value_;
        return *this;
    }
 
    [[nodiscard]] constexpr flags operator&(flags other) const noexcept { return flags{value_ & other.value_}; }
 
    constexpr flags& operator&=(flags other) noexcept {
        value_ &= other.value_;
        return *this;
    }
 
    [[nodiscard]] constexpr flags operator^(flags other) const noexcept { return flags{value_ ^ other.value_}; }
 
    constexpr flags& operator^=(flags other) noexcept {
        value_ ^= other.value_;
        return *this;
    }
 
    [[nodiscard]] constexpr flags operator-(flags other) const noexcept { return flags{value_ & ~other.value_}; }
 
    constexpr flags& operator-=(flags other) noexcept {
        value_ &= ~other.value_;
        return *this;
    }
 
    [[nodiscard]] constexpr flags operator~() const noexcept { return flags{~value_}; }
 
    [[nodiscard]] constexpr bool contains(flags other) const noexcept {
        return other.value_ != 0 && (value_ & other.value_) == other.value_;
    }
 
    [[nodiscard]] constexpr bool contains_any(flags other) const noexcept { return (value_ & other.value_) != 0; }
 
    [[nodiscard]] constexpr bool empty() const noexcept { return value_ == 0; }
 
    [[nodiscard]] constexpr explicit operator bool() const noexcept { return value_ != 0; }
 
    [[nodiscard]] constexpr underlying value() const noexcept { return value_; }
 
    [[nodiscard]] static constexpr flags from_raw(underlying v) noexcept { return flags{v}; }
 
    [[nodiscard]] constexpr bool operator==(flags const&) const noexcept = default;
 
    [[nodiscard]] constexpr bool operator==(E e) const noexcept { return value_ == std::to_underlying(e); }
};
 
template<flag_enum E>
flags(E) -> flags<E>;
 
template<flag_enum E>
[[nodiscard]] constexpr flags<E> operator|(E a, E b) noexcept {
    return flags<E>{a} | flags<E>{b};
}
 
template<flag_enum E>
[[nodiscard]] constexpr flags<E> operator&(E a, E b) noexcept {
    return flags<E>{a} & flags<E>{b};
}
 
template<flag_enum E>
[[nodiscard]] constexpr flags<E> operator^(E a, E b) noexcept {
    return flags<E>{a} ^ flags<E>{b};
}
 
template<flag_enum E>
[[nodiscard]] constexpr flags<E> operator~(E a) noexcept {
    return ~flags<E>{a};
}
 
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), f.value(), 16);
    return std::string(buf, ptr);
}
 
} // namespace idfxx
 
#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