Add utf8 shrink functions

commit_hash:eebf8de05f89401d692625c13336aad120b149fc

Author: nemal300

util/charset/utf8.cpp

@@ -81,6 +81,29 @@ namespace {
         Y_ASSERT(false);
         return false;
     }
+
+    // return longest valid utf-8 prefix size in bytes that is less than or equal to |size|
+    size_t GetLongestUtf8PrefixSize(TStringBuf sb, size_t size, bool robust) {
+        const unsigned char* beg = reinterpret_cast<const unsigned char*>(sb.data());
+        const unsigned char* end = reinterpret_cast<const unsigned char*>(sb.data() + sb.size());
+        const unsigned char* cur = beg;
+        while (cur < end && static_cast<size_t>(cur - beg) < size) {
+            size_t runeLen;
+            if (RECODE_OK != GetUTF8CharLen(runeLen, cur, end)) {
+                if (robust) {
+                    break;
+                } else {
+                    ythrow yexception() << "invalid UTF-8 char at pos " << (cur - beg);
+                }
+            }
+            if ((cur - beg) + runeLen > size) {
+                break;
+            }
+            cur += runeLen;
+        }
+        return cur - beg;
+    }
+
 } // namespace
 
 extern const wchar32 BROKEN_RUNE = 0xFFFD;
@@ -169,3 +192,25 @@ TString ToUpperUTF8(TStringBuf s) {
 TString ToUpperUTF8(const char* s) {
     return ToUpperUTF8(TStringBuf(s));
 }
+
+void Utf8TruncateInplace(TString& s, size_t size) {
+    const size_t prefixSize = GetLongestUtf8PrefixSize(TStringBuf{s}, size, false);
+    if (prefixSize != s.size()) {
+        s.resize(prefixSize);
+    }
+}
+
+void Utf8TruncateInplaceRobust(TString& s, size_t size) {
+    const size_t prefixSize = GetLongestUtf8PrefixSize(TStringBuf{s}, size, true);
+    if (prefixSize != s.size()) {
+        s.resize(prefixSize);
+    }
+}
+
+TStringBuf Utf8Truncate(TStringBuf sb Y_LIFETIME_BOUND, size_t size) {
+    return sb.substr(0, GetLongestUtf8PrefixSize(sb, size, false));
+}
+
+TStringBuf Utf8TruncateRobust(TStringBuf sb Y_LIFETIME_BOUND, size_t size) noexcept {
+    return sb.substr(0, GetLongestUtf8PrefixSize(sb, size, true));
+}

util/charset/utf8.h

@@ -442,3 +442,11 @@ bool ToUpperUTF8Impl(const char* beg, size_t n, TString& newString);
 TString ToUpperUTF8(const TString& s);
 TString ToUpperUTF8(TStringBuf s);
 TString ToUpperUTF8(const char* s);
+
+//! cut utf-8 string to fit into |size| bytes
+void Utf8TruncateInplace(TString& s, size_t size);
+//! cut on a valid utf-8 sequence less or equal |size|
+void Utf8TruncateInplaceRobust(TString& s, size_t size);
+[[nodiscard]] TStringBuf Utf8Truncate(TStringBuf sb Y_LIFETIME_BOUND, size_t size);
+//! on error returns the longest valid utf8 sequence
+[[nodiscard]] TStringBuf Utf8TruncateRobust(TStringBuf sb Y_LIFETIME_BOUND, size_t size) noexcept;

util/charset/utf8_ut.cpp

@@ -123,4 +123,52 @@ Y_UNIT_TEST_SUITE(TUtfUtilTest) {
         wtextScalar.remove(wtextSSE.size());
         UNIT_ASSERT(wtextScalar == wtextSSE);
     }
+
+    Y_UNIT_TEST(TestUtf8TruncateInplace) {
+        TString s = "Съешь ещё этих мягких французских булок, да выпей же чаю.";
+        Utf8TruncateInplace(s, 0u);
+        UNIT_ASSERT_EQUAL(s, "");
+
+        s = "Съешь ещё этих мягких французских булок, да выпей же чаю.";
+        Utf8TruncateInplace(s, 10u);
+        UNIT_ASSERT_EQUAL(s, "Съешь");
+
+        s = "Съешь ещё этих мягких французских булок, да выпей же чаю.";
+        TString s_copy = s;
+        Utf8TruncateInplace(s, s.size());
+        UNIT_ASSERT_EQUAL(s, s_copy);
+
+        Utf8TruncateInplace(s, Max());
+        UNIT_ASSERT_EQUAL(s, s_copy);
+    }
+
+    Y_UNIT_TEST(TestUtf8TruncateCorrupted) {
+        const TString s = "Съешь ещё этих мягких французских булок, да выпей же чаю.";
+        TStringBuf corrupted{s, 0u, 21u};
+        UNIT_ASSERT_EXCEPTION_CONTAINS(Y_UNUSED(Utf8Truncate(corrupted, 21u)), yexception, "invalid UTF-8 char");
+        UNIT_ASSERT_NO_EXCEPTION(Y_UNUSED(Utf8TruncateRobust(corrupted, 21u)));
+        TStringBuf fixed = Utf8TruncateRobust(corrupted, 21u);
+        UNIT_ASSERT_LE(fixed.size(), 21u);
+        UNIT_ASSERT_EQUAL(fixed, "Съешь ещё э");
+    }
+
+    Y_UNIT_TEST(TestUtf8CutInvalidSuffixInplace) {
+        TString s = "Съешь ещё этих мягких французских булок, да выпей же чаю.";
+        s.resize(21);
+        UNIT_ASSERT_UNEQUAL(s, "Съешь ещё э");
+        Utf8TruncateInplaceRobust(s, s.size());
+        UNIT_ASSERT_EQUAL(s, "Съешь ещё э");
+    }
+
+    Y_UNIT_TEST(TestUtf8CutInvalidSuffix) {
+        TStringBuf sb = "Съешь ещё этих мягких французских булок, да выпей же чаю."sv;
+        UNIT_ASSERT_EQUAL(Utf8TruncateRobust(sb, sb.size()), sb);
+        UNIT_ASSERT_EQUAL(Utf8TruncateRobust(sb.substr(0, 21), sb.size()), "Съешь ещё э"sv);
+    }
+
+    Y_UNIT_TEST(TestUtf8TruncateCornerCases) {
+        UNIT_ASSERT_EQUAL(Utf8Truncate("①②③"sv, 4).size(), 3);
+        UNIT_ASSERT_VALUES_EQUAL(Utf8Truncate("foobar"sv, Max()), "foobar"sv);
+    }
+
 } // Y_UNIT_TEST_SUITE(TUtfUtilTest)