react-native-executorch 0.10.6 → 0.10.7

package/third-party/common/phonemis/src/phonemis/base/processor/layers/num2word/notation.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include "types.h"
+
+namespace phonemis::processor::num2word {
+
+// How numbers are written in a language, read by the generic patterns.
+struct Notation {
+  std::u32string group_separators;   // 1.000, 1 000, 1,000
+  std::u32string decimal_separators; // 1,5, 1.5
+  std::u32string time_separators;    // 18:30, 18.30, 18h30
+  Keys time_suffixes;                // pm, Uhr, h
+  Keys currencies;                   // $, zł, EUR
+  Keys scales;                       // million, mln, k
+  Keys units;                        // km, kg, °C
+  bool fractions = false;            // Whether 3/4 reads as a fraction
+};
+
+// The keys of a table, for a Notation built out of a language's constants.
+template <typename Table>
+Keys keys_of(const Table& table) {
+  Keys keys;
+  keys.reserve(table.size());
+  for (const auto& [key, value] : table) {
+    keys.emplace_back(key);
+  }
+  return keys;
+}
+
+} // namespace phonemis::processor::num2word

package/third-party/common/phonemis/src/phonemis/base/processor/layers/num2word/numerals.cpp

@@ -0,0 +1,51 @@
+#include "numerals.h"
+#include "primitives.h"
+#include <phonemis/utils/unicode.h>
+
+namespace phonemis::processor::num2word {
+
+using namespace utils;
+std::optional<uint64_t> value_of(std::u32string_view digits) {
+  if (digits.empty() || digits.size() > 18) {
+    return std::nullopt;
+  }
+
+  uint64_t value = 0;
+  for (char32_t c : digits) {
+    value = value * 10 + static_cast<uint64_t>(c - U'0');
+  }
+  return value;
+}
+
+bool spoken_digits(const Number& number, size_t longest) {
+  const auto& i = number.integer;
+  return (i.size() > 1 && i[0] == U'0') || (i.size() >= longest && !number.grouped && !i.ends_with(U"000"));
+}
+
+std::vector<std::u32string_view> code_parts(std::u32string_view code) {
+  auto is_mark = [](char32_t c) { return c == U'\'' || c == U'.' || c == U'-'; };
+
+  std::vector<std::u32string_view> parts;
+  for (size_t i = 0; i < code.size();) {
+    size_t end = i + 1;
+    if (unicode::isdigit(code[i])) {
+      // 264, 2.5
+      end = digits_end(code, i);
+      if (end + 1 < code.size() && code[end] == U'.' && unicode::isdigit(code[end + 1])) {
+        end = digits_end(code, end + 1);
+      }
+    } else if (code[i] == U'.' && i + 1 < code.size() && unicode::isdigit(code[i + 1])) {
+      // .264
+      end = digits_end(code, i + 1);
+    } else if (!is_mark(code[i])) {
+      while (end < code.size() && !unicode::isdigit(code[end]) && !is_mark(code[end])) {
+        end++;
+      }
+    }
+    parts.push_back(code.substr(i, end - i));
+    i = end;
+  }
+  return parts;
+}
+
+} // namespace phonemis::processor::num2word

package/third-party/common/phonemis/src/phonemis/base/processor/layers/num2word/numerals.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include "../../common/text.h"
+#include "types.h"
+
+#include <cstdint>
+#include <optional>
+#include <span>
+#include <string>
+#include <string_view>
+#include <vector>
+
+/**
+ * Number helpers
+ *
+ * Shared steps of the languages' readings: values of digits, digit-by-digit decisions,
+ * the parts of codes and joining words.
+ */
+namespace phonemis::processor::num2word {
+
+// The value of a run of digits; nullopt if it is empty or too long to hold.
+std::optional<uint64_t> value_of(std::u32string_view digits);
+
+// Whether an integer is read digit by digit: a leading zero, or a long code that is not a round amount.
+bool spoken_digits(const Number& number, size_t longest);
+
+// The parts of a code (MP3, H.264, F-16s): digits with their decimals, ".digits", runs of other characters,
+// and single apostrophes, dots and hyphens.
+std::vector<std::u32string_view> code_parts(std::u32string_view code);
+
+} // namespace phonemis::processor::num2word

package/third-party/common/phonemis/src/phonemis/base/processor/layers/num2word/pattern.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include "kind.h"
+#include "types.h"
+
+#include <optional>
+#include <string_view>
+
+namespace phonemis::processor::num2word {
+
+// Recognizes one kind of numeric expression at a given position of a text.
+class Pattern {
+public:
+  explicit Pattern(Kind kind) : kind_(kind) {}
+  virtual ~Pattern() = default;
+
+  Kind kind() const { return kind_; }
+
+  /**
+   * Matches the expression starting at given position, if there is one.
+   * @param text the text, as rewritten by the patterns before.
+   * @param position where the expression has to start.
+   */
+  virtual std::optional<Match> match(std::u32string_view text, size_t position) const = 0;
+
+private:
+  Kind kind_;
+};
+
+} // namespace phonemis::processor::num2word

package/third-party/common/phonemis/src/phonemis/base/processor/layers/num2word/pattern_set.cpp

@@ -0,0 +1,17 @@
+#include "pattern_set.h"
+
+#include <algorithm>
+
+namespace phonemis::processor::num2word {
+
+void PatternSet::add(std::unique_ptr<Pattern> pattern, Origin origin) {
+  auto priority = [](Kind kind, Origin origin) { return std::pair(kind, origin); };
+  auto key = priority(pattern->kind(), origin);
+
+  // After every pattern of the same or a higher priority
+  auto it = std::ranges::upper_bound(entries_, key, {},
+                                     [&](const Entry& entry) { return priority(entry.pattern->kind(), entry.origin); });
+  entries_.insert(it, {std::move(pattern), origin});
+}
+
+} // namespace phonemis::processor::num2word

package/third-party/common/phonemis/src/phonemis/base/processor/layers/num2word/pattern_set.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include "pattern.h"
+
+#include <memory>
+#include <vector>
+
+namespace phonemis::processor::num2word {
+
+// Where a pattern comes from: within a kind, a language's own patterns go before the generic ones.
+enum class Origin { LANGUAGE = 0, GENERIC };
+
+// Patterns in priority order: by kind (see kind.h), then by origin, then by addition.
+class PatternSet {
+public:
+  struct Entry {
+    std::unique_ptr<Pattern> pattern;
+    Origin origin;
+  };
+
+  void add(std::unique_ptr<Pattern> pattern, Origin origin);
+
+  // Iteration in priority order
+  auto begin() const { return entries_.begin(); }
+  auto end() const { return entries_.end(); }
+
+private:
+  std::vector<Entry> entries_;
+};
+
+} // namespace phonemis::processor::num2word