teaql-cpp/teaql_runtime/src/i18n_debug.cpp at main · teaql/teaql-cpp · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
#include <teaql/runtime/i18n_debug.hpp>
#include <teaql/runtime/detail/builtin_i18n_data.hpp>
#include <algorithm>

namespace teaql {
namespace {
template <class Entries>
void write_entries(DebugWriter& writer, const Entries& entries) {
    writer.sequence(
        entries,
        [](auto& out, const auto& entry) {
            out.text(entry.first);
            out.raw(": ");
            out.text(entry.second);
        },
        "{",
        "}");
}

template <class Messages, class Vocabulary>
void write_locale(DebugWriter& writer, const Messages& messages, const Vocabulary& vocabulary) {
    writer.structure("LocaleCatalog", [&](auto& fields) {
        fields.field("messages", [&](auto& out) {
            write_entries(out, messages);
        });
        fields.field("vocabulary", [&](auto& out) {
            write_entries(out, vocabulary);
        });
    });
}

void write_builtin_locales(DebugWriter& writer) {
    using Entry = detail::BuiltinI18nEntry;
    std::pmr::map<std::string_view, std::pmr::vector<const Entry*>> groups(
        writer.memory_resource());
    for (const auto& entry : detail::builtin_i18n_entries) {
        groups.try_emplace(entry.locale).first->second.push_back(&entry);
    }
    for (auto& [locale, entries] : groups) {
        std::ranges::sort(entries, [](const auto* a, const auto* b) {
            return a->key < b->key;
        });
    }
    writer.sequence(
        groups,
        [](auto& out, const auto& group) {
            out.text(group.first);
            out.raw(": ");
            out.structure("LocaleCatalog", [&](auto& fields) {
                for (bool vocabulary : {false, true}) {
                    fields.field(vocabulary ? "vocabulary" : "messages", [&](auto& inner) {
                        auto entries = group.second | std::views::filter([&](const auto* entry) {
                                           return entry->vocabulary == vocabulary;
                                       });
                        inner.sequence(
                            entries,
                            [](auto& value, const auto* entry) {
                                value.text(entry->key);
                                value.raw(": ");
                                value.text(entry->text);
                            },
                            "{",
                            "}");
                    });
                }
            });
        },
        "{",
        "}");
}
}

void write_debug(DebugWriter& writer, const I18nCatalog& catalog) {
    writer.structure("I18nCatalog", [&](auto& fields) {
        fields.field("default_locale", [&](auto& out) {
            out.text(catalog.default_locale_);
        });
        fields.field("locales", [&](auto& out) {
            if (catalog.builtin_) {
                write_builtin_locales(out);
            } else {
                out.sequence(
                    catalog.locales_,
                    [](auto& inner, const auto& locale) {
                        inner.text(locale.first);
                        inner.raw(": ");
                        write_locale(inner, locale.second.messages, locale.second.vocabulary);
                    },
                    "{",
                    "}");
            }
        });
        fields.field("fallback", [&](auto& out) {
            if (catalog.fallback_) {
                out.tuple("Some", [&](auto& inner) {
                    auto builtin = I18nCatalog::builtin(inner.memory_resource());
                    write_debug(inner, builtin);
                });
            } else {
                out.raw("None");
            }
        });
    });
}
}