markup.hpp

Go to the documentation of this file.

 
 
#pragma once
 
#include "grapheme.hpp"
#include "phrasing.hpp"
#include "gstring.hpp"
#include "../i18n/i18n.hpp"
#include "../utility/utility.hpp"
#include <string>
#include <string_view>
#include <algorithm>
#include <iterator>
#include <ranges>
#include <concepts>
 
hi_export_module(hikogui.unicode.markup);
 
hi_export namespace hi { inline namespace v1 {


hi_export template<std::input_or_output_iterator It, std::sentinel_for<It> ItEnd>
constexpr It
apply_markup(It first, ItEnd last, language_tag default_language = language_tag{"en-US"}, phrasing default_phrasing = phrasing::regular) noexcept
    requires std::same_as<typename It::value_type, grapheme>
{
    enum class state_type { idle, command };
 
    auto src_it = first;
    auto dst_it = first;
    auto command_start = first;
 
    default_language = default_language.expand();
    auto current_language = default_language;
    auto current_phrasing = default_phrasing;
 
    auto write_character = [&](grapheme c) {
        c.set_language_tag(current_language);
        c.set_phrasing(current_phrasing);
        *dst_it++ = c;
    };
 
    auto write_command = [&](gstring_view command) {
        write_character('[');
        for (auto c : command) {
            write_character(c);
        }
        write_character(']');
    };
 
    auto state = state_type::idle;
    while (src_it != last) {
        auto c = *src_it++;
 
        if (state == state_type::idle) {
            if (c == '[') {
                command_start = src_it;
                state = state_type::command;
            } else {
                write_character(c);
            }
 
        } else if (state == state_type::command) {
            if (c == '[') {
                // Escaped open bracket.
                write_character(c);
                state = state_type::idle;
 
            } else if (c == ']') {
                // End of command.
                auto command = gstring_view{command_start, src_it - 1};
                if (command.empty()) {
                    // An empty command is an error, keep the command in the text.
                    write_command(command);
 
                } else if (command.size() == 1) {
                    if (auto const command_g = command.front(); command_g.is_ascii()) {
                        auto const command_c = char_cast<char>(command_g.starter());
                        if (command_c == '.') {
                            current_language = default_language;
                            current_phrasing = default_phrasing;
 
                        } else if (auto p = to_phrasing(command_c)) {
                            current_phrasing = *p;
 
                        } else {
                            // Unknown command, leep the command in the text.
                            write_command(command);
                        }
 
                    } else {
                        // Unknown command, keep the command in the text.
                        write_command(command);
                    }
 
                } else {
                    try {
                        current_language = language_tag{to_string(command)}.expand();
                    } catch (...) {
                        // Leave the full command in the output.
                        write_command(command);
                    }
                }
                state = state_type::idle;
            }
        }
    }
 
    return dst_it;
}

hi_export [[nodiscard]] constexpr gstring
apply_markup(gstring str, language_tag default_language = language_tag{"en-US"}, phrasing default_phrasing = phrasing::regular) noexcept
{
    auto it = apply_markup(str.begin(), str.end(), default_language, default_phrasing);
    str.erase(it, str.end());
    return str;
}

hi_export [[nodiscard]] constexpr gstring
apply_markup(std::string_view str, language_tag default_language = language_tag{"en-US"}, phrasing default_phrasing = phrasing::regular) noexcept
{
    return apply_markup(to_gstring(str), default_language, default_phrasing);
}
 
}} // namespace hi::v1