phrasing.hpp

// Copyright Take Vos 2022.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
 
#pragma once
 
#include "../utility/module.hpp"
#include <cstdint>
#include <optional>
#include <bit>
 
namespace hi::inline v1 {
 
enum class phrasing : uint8_t {
    regular = 0,
 
    emphesis = 1,
 
    strong = 2,
 
    code = 3,
 
    abbreviation = 4,
 
    quote = 5,
 
    keyboard = 6,
 
    highlight = 7,
 
    math = 8,
 
    example = 9, 
 
    unarticulated = 10,
 
    title = 11,
 
    success = 12,
 
    warning = 13,
 
    error = 14,
};
 
// clang-format off
constexpr auto phrasing_metadata = enum_metadata{
    phrasing::regular, "regular",
    phrasing::emphesis, "emphesis",
    phrasing::strong, "strong",
    phrasing::code, "code",
    phrasing::abbreviation, "abbreviation",
    phrasing::quote, "quote",
    phrasing::keyboard, "keyboard",
    phrasing::highlight, "highlight",
    phrasing::math, "math",
    phrasing::example, "example",
    phrasing::unarticulated, "unarticulated",
    phrasing::title, "title",
    phrasing::success, "success",
    phrasing::warning, "warning",
    phrasing::error, "error",
};
// clang-format on
 
// clang-format off
[[nodiscard]] constexpr std::optional<phrasing> to_phrasing(char c)
{
    switch (c) {
    case 'r': return phrasing::regular;
    case 'e': return phrasing::emphesis;
    case 's': return phrasing::strong;
    case 'c': return phrasing::code;
    case 'a': return phrasing::abbreviation;
    case 'q': return phrasing::quote;
    case 'k': return phrasing::keyboard;
    case 'h': return phrasing::highlight;
    case 'm': return phrasing::math;
    case 'x': return phrasing::example;
    case 'u': return phrasing::unarticulated;
    case 't': return phrasing::title;
    case 'S': return phrasing::success;
    case 'W': return phrasing::warning;
    case 'E': return phrasing::error;
    default:
        return std::nullopt;
    }
}
// clang-format on
 
enum class phrasing_mask : uint16_t {
    regular = 1 << std::to_underlying(phrasing::regular),
    emphesis = 1 << std::to_underlying(phrasing::emphesis),
    strong = 1 << std::to_underlying(phrasing::strong),
    code = 1 << std::to_underlying(phrasing::code),
    abbreviation = 1 << std::to_underlying(phrasing::abbreviation),
    quote = 1 << std::to_underlying(phrasing::quote),
    keyboard = 1 << std::to_underlying(phrasing::keyboard),
    highlight = 1 << std::to_underlying(phrasing::highlight),
    math = 1 << std::to_underlying(phrasing::math),
    example = 1 << std::to_underlying(phrasing::example),
    unarticulated = 1 << std::to_underlying(phrasing::unarticulated),
    title = 1 << std::to_underlying(phrasing::title),
    success = 1 << std::to_underlying(phrasing::success),
    warning = 1 << std::to_underlying(phrasing::warning),
    error = 1 << std::to_underlying(phrasing::error),
 
    all = regular | emphesis | strong | code | abbreviation | quote | keyboard | highlight | math | example | unarticulated |
        title | success | warning | error
};
 
static_assert(
    std::bit_width(phrasing_metadata.size() - 1) <= sizeof(std::underlying_type_t<phrasing_mask>) * CHAR_BIT,
    "All phrasings must fit the phrasing_mask.");
 
[[nodiscard]] constexpr phrasing_mask operator&(phrasing_mask const& lhs, phrasing_mask const& rhs) noexcept
{
    return static_cast<phrasing_mask>(std::to_underlying(lhs) & std::to_underlying(rhs));
}
 
[[nodiscard]] constexpr phrasing_mask operator|(phrasing_mask const& lhs, phrasing_mask const& rhs) noexcept
{
    return static_cast<phrasing_mask>(std::to_underlying(lhs) | std::to_underlying(rhs));
}
 
[[nodiscard]] constexpr phrasing_mask to_phrasing_mask(phrasing const& rhs) noexcept
{
    hi_axiom(std::to_underlying(rhs) < sizeof(phrasing_mask) * CHAR_BIT);
    return static_cast<phrasing_mask>(1 << std::to_underlying(rhs));
}
 
[[nodiscard]] constexpr phrasing_mask to_phrasing_mask(std::string const& str)
{
    auto r = phrasing_mask{};
 
    for (hilet c : str) {
        if (c == '*') {
            r = phrasing_mask::all;
        } else if (hilet p = to_phrasing(c)) {
            r = r | to_phrasing_mask(*p);
        } else {
            throw parse_error(std::format("Unknown character '{}' in text-phrasing-mask", c));
        }
    }
 
    return r;
}
 
[[nodiscard]] constexpr bool all(phrasing_mask const& rhs) noexcept
{
    return (rhs & phrasing_mask::all) == phrasing_mask::all;
}
 
[[nodiscard]] constexpr bool to_bool(phrasing_mask const& rhs) noexcept
{
    return to_bool(std::to_underlying(rhs));
}
 
[[nodiscard]] constexpr bool matches(phrasing_mask const& lhs, phrasing const& rhs) noexcept
{
    return to_bool(lhs & to_phrasing_mask(rhs));
}
 
} // namespace hi::inline v1