Rename Unicode to UnicodeTranscoder (#25)

Review follow-up. The class transcodes between UTF-8, UTF-16 and code
points; "Unicode" names a domain that also covers normalization, case
mapping and collation, none of which this does. UnicodeTranscoder states
the actual responsibility and keeps the scope from drifting.

Identifier rename only, with no behavior change: the four method names,
their signatures, the validation rules and the file layout are untouched.
The header stays internal.

Verified locally on Linux GCC at C++11 and C++20: 124/124 tests pass in
both, clang-format clean on the changed files.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01YLXHcZjrnrdhRZAgqDh6kd

Author: claude

src/internal/unicode.h

@@ -51,7 +51,7 @@ namespace sqlite_reflection {
 /// wchar_t is 16 bits, no longer reads back. That data was stored ill-formed; because encoding
 /// and decoding were wrong in the same way it used to survive a round trip on Windows, so the
 /// break surfaces only now. See the text encoding section of README.md.
-class REFLECTION_EXPORT Unicode {
+class REFLECTION_EXPORT UnicodeTranscoder {
 public:
     /// Encodes Unicode code points as UTF-8
     static std::string Utf8FromCodePoints(const char32_t* code_points, size_t count);

src/string_utilities.cc

@@ -32,7 +32,7 @@ namespace {
 // Copies a string of code units into a string of a different unit type, one unit at a time. The
 // casts are value-preserving in the directions used below, except for a negative wchar_t on a
 // platform where it is signed, which widens to a value above U+10FFFF and is then rejected by
-// the validation in Unicode.
+// the validation in UnicodeTranscoder.
 template <typename To, typename From>
 To cast_each(const From& source) {
     To result;
@@ -54,11 +54,11 @@ template <>
 struct WideCodec<2> {
     static std::u32string ToCodePoints(const std::wstring& wide_string) {
         const auto code_units = cast_each<std::u16string>(wide_string);
-        return Unicode::CodePointsFromUtf16(code_units.data(), code_units.size());
+        return UnicodeTranscoder::CodePointsFromUtf16(code_units.data(), code_units.size());
     }
 
     static std::wstring FromCodePoints(const std::u32string& code_points) {
-        const auto code_units = Unicode::Utf16FromCodePoints(code_points.data(), code_points.size());
+        const auto code_units = UnicodeTranscoder::Utf16FromCodePoints(code_points.data(), code_points.size());
         return cast_each<std::wstring>(code_units);
     }
 };
@@ -97,11 +97,11 @@ std::string StringUtilities::FromDouble(double value) {
 
 std::string StringUtilities::ToUtf8(const std::wstring& wide_string) {
     const auto code_points = PlatformWideCodec::ToCodePoints(wide_string);
-    return Unicode::Utf8FromCodePoints(code_points.data(), code_points.size());
+    return UnicodeTranscoder::Utf8FromCodePoints(code_points.data(), code_points.size());
 }
 
 std::wstring StringUtilities::FromUtf8(const char* utf8_string, size_t byte_count) {
-    const auto code_points = Unicode::CodePointsFromUtf8(utf8_string, byte_count);
+    const auto code_points = UnicodeTranscoder::CodePointsFromUtf8(utf8_string, byte_count);
     return PlatformWideCodec::FromCodePoints(code_points);
 }
 

src/unicode.cc

@@ -99,7 +99,7 @@ void reject_if_invalid_second_byte(unsigned char lead, unsigned char second) {
 }
 }  // namespace
 
-std::string Unicode::Utf8FromCodePoints(const char32_t* code_points, size_t count) {
+std::string UnicodeTranscoder::Utf8FromCodePoints(const char32_t* code_points, size_t count) {
     std::string utf8_string;
     utf8_string.reserve(count);
 
@@ -127,7 +127,7 @@ std::string Unicode::Utf8FromCodePoints(const char32_t* code_points, size_t coun
     return utf8_string;
 }
 
-std::u32string Unicode::CodePointsFromUtf8(const char* utf8_string, size_t byte_count) {
+std::u32string UnicodeTranscoder::CodePointsFromUtf8(const char* utf8_string, size_t byte_count) {
     std::u32string code_points;
     code_points.reserve(byte_count);
 
@@ -179,7 +179,7 @@ std::u32string Unicode::CodePointsFromUtf8(const char* utf8_string, size_t byte_
     return code_points;
 }
 
-std::u16string Unicode::Utf16FromCodePoints(const char32_t* code_points, size_t count) {
+std::u16string UnicodeTranscoder::Utf16FromCodePoints(const char32_t* code_points, size_t count) {
     std::u16string utf16_string;
     utf16_string.reserve(count);
 
@@ -200,7 +200,7 @@ std::u16string Unicode::Utf16FromCodePoints(const char32_t* code_points, size_t
     return utf16_string;
 }
 
-std::u32string Unicode::CodePointsFromUtf16(const char16_t* utf16_string, size_t count) {
+std::u32string UnicodeTranscoder::CodePointsFromUtf16(const char16_t* utf16_string, size_t count) {
     std::u32string code_points;
     code_points.reserve(count);
 

tests/unicode_test.cc

@@ -136,19 +136,19 @@ TEST(UnicodeTest, SupplementaryCodePointSurvivesLengthAndContent) {
 
 namespace {
 std::u32string CodePoints(const std::string& utf8) {
-    return Unicode::CodePointsFromUtf8(utf8.data(), utf8.size());
+    return UnicodeTranscoder::CodePointsFromUtf8(utf8.data(), utf8.size());
 }
 
 std::string Utf8From(const std::u32string& code_points) {
-    return Unicode::Utf8FromCodePoints(code_points.data(), code_points.size());
+    return UnicodeTranscoder::Utf8FromCodePoints(code_points.data(), code_points.size());
 }
 
 std::u16string Utf16From(const std::u32string& code_points) {
-    return Unicode::Utf16FromCodePoints(code_points.data(), code_points.size());
+    return UnicodeTranscoder::Utf16FromCodePoints(code_points.data(), code_points.size());
 }
 
 std::u32string FromUtf16(const std::u16string& code_units) {
-    return Unicode::CodePointsFromUtf16(code_units.data(), code_units.size());
+    return UnicodeTranscoder::CodePointsFromUtf16(code_units.data(), code_units.size());
 }
 }  // namespace