icon.hpp

Go to the documentation of this file.

#pragma once
 
 
#include <commons/fixed_string.hpp>
#include <commons/types.hpp>
 
#include <format>
#include <optional>
#include <ostream>
#include <stdexcept>
#include <string>
#include <string_view>
 
namespace comms {
 
struct Icon {
    static constexpr usize capacity = 64;
 
    // -- construction -------------------------------------------------------
 
    constexpr Icon() = default;
 
    [[nodiscard]] static constexpr Icon from(const std::string_view value) {
        if (value.size() > capacity) {
            throw std::length_error{"commons: Icon value exceeds capacity"};
        }
        const auto parsed = parse(value);
        if (!parsed) {
            throw std::invalid_argument{"commons: invalid Icon value (expected 'set:name')"};
        }
        return *parsed;
    }
 
    [[nodiscard]] static constexpr Icon from(const std::string_view set,
                                             const std::string_view name) {
        const usize total = set.size() + 1U + name.size();
        if (total > capacity) {
            throw std::length_error{"commons: Icon 'set:name' exceeds capacity"};
        }
        // NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)
        char tmp[capacity]{};
        usize k = 0;
        for (const char c : set) {
            tmp[k++] = c;
        }
        tmp[k++] = ':';
        for (const char c : name) {
            tmp[k++] = c;
        }
        const auto parsed = parse(std::string_view{static_cast<const char*>(tmp), total});
        if (!parsed) {
            throw std::invalid_argument{
                "commons: invalid Icon set/name (expected non-empty parts)"};
        }
        return *parsed;
    }
 
    [[nodiscard]] static constexpr std::optional<Icon> parse(const std::string_view value) {
        if (value.size() > capacity) {
            return std::nullopt;
        }
        usize colon = std::string_view::npos;
        usize colons = 0;
        for (usize i = 0; i < value.size(); ++i) {
            if (value[i] == ':') {
                colon = i;
                ++colons;
            }
        }
        if (colons != 1 || colon == 0 || colon + 1 == value.size()) {
            return std::nullopt;
        }
        Icon icon;
        for (usize i = 0; i < value.size(); ++i) {
            icon.buf_[i] = value[i];
        }
        icon.len_ = static_cast<u8>(value.size());
        return icon;
    }
 
    // -- accessors ----------------------------------------------------------
 
    [[nodiscard]] constexpr std::string_view value() const noexcept {
        return std::string_view{static_cast<const char*>(buf_), len_};
    }
 
    [[nodiscard]] constexpr std::string_view set() const noexcept {
        const auto v = value();
        return v.substr(0, colon_index(v));
    }
 
    [[nodiscard]] constexpr std::string_view name() const noexcept {
        const auto v = value();
        const auto pos = colon_index(v);
        return pos == std::string_view::npos ? std::string_view{} : v.substr(pos + 1);
    }
 
    [[nodiscard]] constexpr bool empty() const noexcept {
        return len_ == 0;
    }
 
    [[nodiscard]] std::string to_string() const {
        return std::string{value()};
    }
 
    bool operator==(const Icon&) const = default;
 
private:
    [[nodiscard]] static constexpr usize colon_index(std::string_view v) noexcept {
        for (usize i = 0; i < v.size(); ++i) {
            if (v[i] == ':') {
                return i;
            }
        }
        return std::string_view::npos;
    }
 
    // NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays)
    char buf_[capacity]{};
    u8 len_ = 0;
};
 
template <FixedString Set>
struct IconifySet {
    static constexpr std::string_view set = Set.view();
};
 
// ---------------------------------------------------------------------------
// Text output: to_string + std::ostream insertion. (std::format support is the
// std::formatter specialization below, outside namespace comms.)
// ---------------------------------------------------------------------------
 
[[nodiscard]] inline std::string to_string(const Icon& i) {
    return i.to_string();
}
 
inline std::ostream& operator<<(std::ostream& os, const Icon& i) {
    return os << i.value();
}
 
}  // namespace comms
 
// ---------------------------------------------------------------------------
// std::format support. The specialization lives in namespace std (the primary
// template is visible), like nlohmann's adl_serializer route in json.hpp.
// ---------------------------------------------------------------------------
 
// This spec-less formatter reads no member state, but `std::formatter` requires
// `parse`/`format` to be non-static members — so silence the convert-to-static
// suggestion here.
// NOLINTBEGIN(readability-convert-member-functions-to-static)
 
template <>
struct std::formatter<comms::Icon> {
    constexpr auto parse(const std::format_parse_context& ctx) {
        const auto* it = ctx.begin();
        if (it != ctx.end() && *it != '}') {
            throw std::format_error("commons: Icon takes no format spec");
        }
        return it;
    }
 
    auto format(const comms::Icon& i, std::format_context& ctx) const {
        return std::format_to(ctx.out(), "{}", i.value());
    }
};
 
// NOLINTEND(readability-convert-member-functions-to-static)