xref: /third_party/node/deps/simdutf/simdutf.cpp

69   simdutf_warn_unused bool validate_utf8(const char *buf, size_t len) const noexcept final;
70   simdutf_warn_unused result validate_utf8_with_errors(const char *buf, size_t len) const noexcept final;
71   simdutf_warn_unused bool validate_ascii(const char *buf, size_t len) const noexcept final;
72   simdutf_warn_unused result validate_ascii_with_errors(const char *buf, size_t len) const noexcept final;
73   simdutf_warn_unused bool validate_utf16le(const char16_t *buf, size_t len) const noexcept final;
74   simdutf_warn_unused bool validate_utf16be(const char16_t *buf, size_t len) const noexcept final;
75   simdutf_warn_unused result validate_utf16le_with_errors(const char16_t *buf, size_t len) const noexcept final;
76   simdutf_warn_unused result validate_utf16be_with_errors(const char16_t *buf, size_t len) const noexcept final;
77   simdutf_warn_unused bool validate_utf32(const char32_t *buf, size_t len) const noexcept final;
78   simdutf_warn_unused result validate_utf32_with_errors(const char32_t *buf, size_t len) const noexcept final;
79   simdutf_warn_unused size_t convert_latin1_to_utf8(const char * buf, size_t len, char* utf8_output) const noexcept final;
80   simdutf_warn_unused size_t convert_latin1_to_utf16le(const char * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
81   simdutf_warn_unused size_t convert_latin1_to_utf16be(const char * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
82   simdutf_warn_unused size_t convert_latin1_to_utf32(const char * buf, size_t len, char32_t* utf32_output) const noexcept final;
83   simdutf_warn_unused size_t convert_utf8_to_latin1(const char * buf, size_t len, char* latin1_output) const noexcept final;
84   simdutf_warn_unused result convert_utf8_to_latin1_with_errors(const char * buf, size_t len, char* latin1_buffer) const noexcept final;
85   simdutf_warn_unused size_t convert_valid_utf8_to_latin1(const char * buf, size_t len, char* latin1_output) const noexcept final;
86   simdutf_warn_unused size_t convert_utf8_to_utf16le(const char * buf, size_t len, char16_t* utf16_output) const noexcept final;
87   simdutf_warn_unused size_t convert_utf8_to_utf16be(const char * buf, size_t len, char16_t* utf16_output) const noexcept final;
88   simdutf_warn_unused result convert_utf8_to_utf16le_with_errors(const char * buf, size_t len, char16_t* utf16_output) const noexcept final;
89   simdutf_warn_unused result convert_utf8_to_utf16be_with_errors(const char * buf, size_t len, char16_t* utf16_output) const noexcept final;
90   simdutf_warn_unused size_t convert_valid_utf8_to_utf16le(const char * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
91   simdutf_warn_unused size_t convert_valid_utf8_to_utf16be(const char * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
92   simdutf_warn_unused size_t convert_utf8_to_utf32(const char * buf, size_t len, char32_t* utf32_output) const noexcept final;
93   simdutf_warn_unused result convert_utf8_to_utf32_with_errors(const char * buf, size_t len, char32_t* utf32_output) const noexcept final;
94   simdutf_warn_unused size_t convert_valid_utf8_to_utf32(const char * buf, size_t len, char32_t* utf32_buffer) const noexcept final;
95   simdutf_warn_unused size_t convert_utf16le_to_latin1(const char16_t * buf, size_t len, char* latin1_buffer) const noexcept final;
96   simdutf_warn_unused size_t convert_utf16be_to_latin1(const char16_t * buf, size_t len, char* latin1_buffer) const noexcept final;
97   simdutf_warn_unused result convert_utf16le_to_latin1_with_errors(const char16_t * buf, size_t len, char* latin1_buffer) const noexcept final;
98   simdutf_warn_unused result convert_utf16be_to_latin1_with_errors(const char16_t * buf, size_t len, char* latin1_buffer) const noexcept final;
99   simdutf_warn_unused size_t convert_valid_utf16le_to_latin1(const char16_t * buf, size_t len, char* latin1_buffer) const noexcept final;
100   simdutf_warn_unused size_t convert_valid_utf16be_to_latin1(const char16_t * buf, size_t len, char* latin1_buffer) const noexcept final;
101   simdutf_warn_unused size_t convert_utf16le_to_utf8(const char16_t * buf, size_t len, char* utf8_buffer) const noexcept final;
102   simdutf_warn_unused size_t convert_utf16be_to_utf8(const char16_t * buf, size_t len, char* utf8_buffer) const noexcept final;
103   simdutf_warn_unused result convert_utf16le_to_utf8_with_errors(const char16_t * buf, size_t len, char* utf8_buffer) const noexcept final;
104   simdutf_warn_unused result convert_utf16be_to_utf8_with_errors(const char16_t * buf, size_t len, char* utf8_buffer) const noexcept final;
105   simdutf_warn_unused size_t convert_valid_utf16le_to_utf8(const char16_t * buf, size_t len, char* utf8_buffer) const noexcept final;
106   simdutf_warn_unused size_t convert_valid_utf16be_to_utf8(const char16_t * buf, size_t len, char* utf8_buffer) const noexcept final;
107   simdutf_warn_unused size_t convert_utf32_to_latin1(const char32_t * buf, size_t len, char* latin1_output) const noexcept final;
108   simdutf_warn_unused result convert_utf32_to_latin1_with_errors(const char32_t * buf, size_t len, char* latin1_output) const noexcept final;
109   simdutf_warn_unused size_t convert_valid_utf32_to_latin1(const char32_t * buf, size_t len, char* latin1_output) const noexcept final;
110   simdutf_warn_unused size_t convert_utf32_to_utf8(const char32_t * buf, size_t len, char* utf8_buffer) const noexcept final;
111   simdutf_warn_unused result convert_utf32_to_utf8_with_errors(const char32_t * buf, size_t len, char* utf8_buffer) const noexcept final;
112   simdutf_warn_unused size_t convert_valid_utf32_to_utf8(const char32_t * buf, size_t len, char* utf8_buffer) const noexcept final;
113   simdutf_warn_unused size_t convert_utf32_to_utf16le(const char32_t * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
114   simdutf_warn_unused size_t convert_utf32_to_utf16be(const char32_t * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
115   simdutf_warn_unused result convert_utf32_to_utf16le_with_errors(const char32_t * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
116   simdutf_warn_unused result convert_utf32_to_utf16be_with_errors(const char32_t * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
117   simdutf_warn_unused size_t convert_valid_utf32_to_utf16le(const char32_t * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
118   simdutf_warn_unused size_t convert_valid_utf32_to_utf16be(const char32_t * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
119   simdutf_warn_unused size_t convert_utf16le_to_utf32(const char16_t * buf, size_t len, char32_t* utf32_buffer) const noexcept final;
120   simdutf_warn_unused size_t convert_utf16be_to_utf32(const char16_t * buf, size_t len, char32_t* utf32_buffer) const noexcept final;
121   simdutf_warn_unused result convert_utf16le_to_utf32_with_errors(const char16_t * buf, size_t len, char32_t* utf32_buffer) const noexcept final;
122   simdutf_warn_unused result convert_utf16be_to_utf32_with_errors(const char16_t * buf, size_t len, char32_t* utf32_buffer) const noexcept final;
123   simdutf_warn_unused size_t convert_valid_utf16le_to_utf32(const char16_t * buf, size_t len, char32_t* utf32_buffer) const noexcept final;
124   simdutf_warn_unused size_t convert_valid_utf16be_to_utf32(const char16_t * buf, size_t len, char32_t* utf32_buffer) const noexcept final;
1269   simdutf_warn_unused bool validate_utf8(const char *buf, size_t len) const noexcept final;
1270   simdutf_warn_unused result validate_utf8_with_errors(const char *buf, size_t len) const noexcept final;
1271   simdutf_warn_unused bool validate_ascii(const char *buf, size_t len) const noexcept final;
1272   simdutf_warn_unused result validate_ascii_with_errors(const char *buf, size_t len) const noexcept final;
1273   simdutf_warn_unused bool validate_utf16le(const char16_t *buf, size_t len) const noexcept final;
1274   simdutf_warn_unused bool validate_utf16be(const char16_t *buf, size_t len) const noexcept final;
1275   simdutf_warn_unused result validate_utf16le_with_errors(const char16_t *buf, size_t len) const noexcept final;
1276   simdutf_warn_unused result validate_utf16be_with_errors(const char16_t *buf, size_t len) const noexcept final;
1277   simdutf_warn_unused bool validate_utf32(const char32_t *buf, size_t len) const noexcept final;
1278   simdutf_warn_unused result validate_utf32_with_errors(const char32_t *buf, size_t len) const noexcept final;
1279   simdutf_warn_unused size_t convert_latin1_to_utf8(const char * buf, size_t len, char* utf8_output) const noexcept final;
1280   simdutf_warn_unused size_t convert_latin1_to_utf16le(const char * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
1281   simdutf_warn_unused size_t convert_latin1_to_utf16be(const char * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
1282   simdutf_warn_unused size_t convert_latin1_to_utf32(const char * buf, size_t len, char32_t* utf32_output) const noexcept final;
1283   simdutf_warn_unused size_t convert_utf8_to_latin1(const char * buf, size_t len, char* latin1_output) const noexcept final;
1284   simdutf_warn_unused result convert_utf8_to_latin1_with_errors(const char * buf, size_t len, char* latin1_buffer) const noexcept final;
1285   simdutf_warn_unused size_t convert_valid_utf8_to_latin1(const char * buf, size_t len, char* latin1_output) const noexcept final;
1286   simdutf_warn_unused size_t convert_utf8_to_utf16le(const char * buf, size_t len, char16_t* utf16_output) const noexcept final;
1287   simdutf_warn_unused size_t convert_utf8_to_utf16be(const char * buf, size_t len, char16_t* utf16_output) const noexcept final;
1288   simdutf_warn_unused result convert_utf8_to_utf16le_with_errors(const char * buf, size_t len, char16_t* utf16_output) const noexcept final;
1289   simdutf_warn_unused result convert_utf8_to_utf16be_with_errors(const char * buf, size_t len, char16_t* utf16_output) const noexcept final;
1290   simdutf_warn_unused size_t convert_valid_utf8_to_utf16le(const char * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
1291   simdutf_warn_unused size_t convert_valid_utf8_to_utf16be(const char * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
1292   simdutf_warn_unused size_t convert_utf8_to_utf32(const char * buf, size_t len, char32_t* utf32_output) const noexcept final;
1293   simdutf_warn_unused result convert_utf8_to_utf32_with_errors(const char * buf, size_t len, char32_t* utf32_output) const noexcept final;
1294   simdutf_warn_unused size_t convert_valid_utf8_to_utf32(const char * buf, size_t len, char32_t* utf32_buffer) const noexcept final;
1295   simdutf_warn_unused size_t convert_utf16le_to_latin1(const char16_t * buf, size_t len, char* latin1_buffer) const noexcept final;
1296   simdutf_warn_unused size_t convert_utf16be_to_latin1(const char16_t * buf, size_t len, char* latin1_buffer) const noexcept final;
1297   simdutf_warn_unused result convert_utf16le_to_latin1_with_errors(const char16_t * buf, size_t len, char* latin1_buffer) const noexcept final;
1298   simdutf_warn_unused result convert_utf16be_to_latin1_with_errors(const char16_t * buf, size_t len, char* latin1_buffer) const noexcept final;
1299   simdutf_warn_unused size_t convert_valid_utf16le_to_latin1(const char16_t * buf, size_t len, char* latin1_buffer) const noexcept final;
1300   simdutf_warn_unused size_t convert_valid_utf16be_to_latin1(const char16_t * buf, size_t len, char* latin1_buffer) const noexcept final;
1301   simdutf_warn_unused size_t convert_utf16le_to_utf8(const char16_t * buf, size_t len, char* utf8_buffer) const noexcept final;
1302   simdutf_warn_unused size_t convert_utf16be_to_utf8(const char16_t * buf, size_t len, char* utf8_buffer) const noexcept final;
1303   simdutf_warn_unused result convert_utf16le_to_utf8_with_errors(const char16_t * buf, size_t len, char* utf8_buffer) const noexcept final;
1304   simdutf_warn_unused result convert_utf16be_to_utf8_with_errors(const char16_t * buf, size_t len, char* utf8_buffer) const noexcept final;
1305   simdutf_warn_unused size_t convert_valid_utf16le_to_utf8(const char16_t * buf, size_t len, char* utf8_buffer) const noexcept final;
1306   simdutf_warn_unused size_t convert_valid_utf16be_to_utf8(const char16_t * buf, size_t len, char* utf8_buffer) const noexcept final;
1307   simdutf_warn_unused size_t convert_utf32_to_utf8(const char32_t * buf, size_t len, char* utf8_buffer) const noexcept final;
1308   simdutf_warn_unused result convert_utf32_to_utf8_with_errors(const char32_t * buf, size_t len, char* utf8_buffer) const noexcept final;
1309   simdutf_warn_unused size_t convert_valid_utf32_to_utf8(const char32_t * buf, size_t len, char* utf8_buffer) const noexcept final;
1310   simdutf_warn_unused size_t convert_utf32_to_latin1(const char32_t * buf, size_t len, char* latin1_output) const noexcept final;
1311   simdutf_warn_unused result convert_utf32_to_latin1_with_errors(const char32_t * buf, size_t len, char* latin1_output) const noexcept final;
1312   simdutf_warn_unused size_t convert_valid_utf32_to_latin1(const char32_t * buf, size_t len, char* latin1_output) const noexcept final;
1313   simdutf_warn_unused size_t convert_utf32_to_utf16le(const char32_t * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
1314   simdutf_warn_unused size_t convert_utf32_to_utf16be(const char32_t * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
1315   simdutf_warn_unused result convert_utf32_to_utf16le_with_errors(const char32_t * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
1316   simdutf_warn_unused result convert_utf32_to_utf16be_with_errors(const char32_t * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
1317   simdutf_warn_unused size_t convert_valid_utf32_to_utf16le(const char32_t * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
1318   simdutf_warn_unused size_t convert_valid_utf32_to_utf16be(const char32_t * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
1319   simdutf_warn_unused size_t convert_utf16le_to_utf32(const char16_t * buf, size_t len, char32_t* utf32_buffer) const noexcept final;
1320   simdutf_warn_unused size_t convert_utf16be_to_utf32(const char16_t * buf, size_t len, char32_t* utf32_buffer) const noexcept final;
1321   simdutf_warn_unused result convert_utf16le_to_utf32_with_errors(const char16_t * buf, size_t len, char32_t* utf32_buffer) const noexcept final;
1322   simdutf_warn_unused result convert_utf16be_to_utf32_with_errors(const char16_t * buf, size_t len, char32_t* utf32_buffer) const noexcept final;
1323   simdutf_warn_unused size_t convert_valid_utf16le_to_utf32(const char16_t * buf, size_t len, char32_t* utf32_buffer) const noexcept final;
1324   simdutf_warn_unused size_t convert_valid_utf16be_to_utf32(const char16_t * buf, size_t len, char32_t* utf32_buffer) const noexcept final;
1476   simdutf_warn_unused bool validate_utf8(const char *buf, size_t len) const noexcept final;
1477   simdutf_warn_unused result validate_utf8_with_errors(const char *buf, size_t len) const noexcept final;
1478   simdutf_warn_unused bool validate_ascii(const char *buf, size_t len) const noexcept final;
1479   simdutf_warn_unused result validate_ascii_with_errors(const char *buf, size_t len) const noexcept final;
1480   simdutf_warn_unused bool validate_utf16le(const char16_t *buf, size_t len) const noexcept final;
1481   simdutf_warn_unused bool validate_utf16be(const char16_t *buf, size_t len) const noexcept final;
1482   simdutf_warn_unused result validate_utf16le_with_errors(const char16_t *buf, size_t len) const noexcept final;
1483   simdutf_warn_unused result validate_utf16be_with_errors(const char16_t *buf, size_t len) const noexcept final;
1484   simdutf_warn_unused bool validate_utf32(const char32_t *buf, size_t len) const noexcept final;
1485   simdutf_warn_unused result validate_utf32_with_errors(const char32_t *buf, size_t len) const noexcept final;
1486   simdutf_warn_unused size_t convert_latin1_to_utf8(const char * buf, size_t len, char* utf8_output) const noexcept final;
1487   simdutf_warn_unused size_t convert_latin1_to_utf16le(const char * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
1488   simdutf_warn_unused size_t convert_latin1_to_utf16be(const char * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
1489   simdutf_warn_unused size_t convert_latin1_to_utf32(const char * buf, size_t len, char32_t* utf32_output) const noexcept final;
1490   simdutf_warn_unused size_t convert_utf8_to_latin1(const char * buf, size_t len, char* latin1_output) const noexcept final;
1491   simdutf_warn_unused result convert_utf8_to_latin1_with_errors(const char * buf, size_t len, char* latin1_buffer) const noexcept final;
1492   simdutf_warn_unused size_t convert_valid_utf8_to_latin1(const char * buf, size_t len, char* latin1_output) const noexcept final;
1493   simdutf_warn_unused size_t convert_utf8_to_utf16le(const char * buf, size_t len, char16_t* utf16_output) const noexcept final;
1494   simdutf_warn_unused size_t convert_utf8_to_utf16be(const char * buf, size_t len, char16_t* utf16_output) const noexcept final;
1495   simdutf_warn_unused result convert_utf8_to_utf16le_with_errors(const char * buf, size_t len, char16_t* utf16_output) const noexcept final;
1496   simdutf_warn_unused result convert_utf8_to_utf16be_with_errors(const char * buf, size_t len, char16_t* utf16_output) const noexcept final;
1497   simdutf_warn_unused size_t convert_valid_utf8_to_utf16le(const char * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
1498   simdutf_warn_unused size_t convert_valid_utf8_to_utf16be(const char * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
1499   simdutf_warn_unused size_t convert_utf8_to_utf32(const char * buf, size_t len, char32_t* utf32_output) const noexcept final;
1500   simdutf_warn_unused result convert_utf8_to_utf32_with_errors(const char * buf, size_t len, char32_t* utf32_output) const noexcept final;
1501   simdutf_warn_unused size_t convert_valid_utf8_to_utf32(const char * buf, size_t len, char32_t* utf32_buffer) const noexcept final;
1502   simdutf_warn_unused size_t convert_utf16le_to_latin1(const char16_t * buf, size_t len, char* latin1_buffer) const noexcept final;
1503   simdutf_warn_unused size_t convert_utf16be_to_latin1(const char16_t * buf, size_t len, char* latin1_buffer) const noexcept final;
1504   simdutf_warn_unused result convert_utf16le_to_latin1_with_errors(const char16_t * buf, size_t len, char* latin1_buffer) const noexcept final;
1505   simdutf_warn_unused result convert_utf16be_to_latin1_with_errors(const char16_t * buf, size_t len, char* latin1_buffer) const noexcept final;
1506   simdutf_warn_unused size_t convert_valid_utf16le_to_latin1(const char16_t * buf, size_t len, char* latin1_buffer) const noexcept final;
1507   simdutf_warn_unused size_t convert_valid_utf16be_to_latin1(const char16_t * buf, size_t len, char* latin1_buffer) const noexcept final;
1508   simdutf_warn_unused size_t convert_utf16le_to_utf8(const char16_t * buf, size_t len, char* utf8_buffer) const noexcept final;
1509   simdutf_warn_unused size_t convert_utf16be_to_utf8(const char16_t * buf, size_t len, char* utf8_buffer) const noexcept final;
1510   simdutf_warn_unused result convert_utf16le_to_utf8_with_errors(const char16_t * buf, size_t len, char* utf8_buffer) const noexcept final;
1511   simdutf_warn_unused result convert_utf16be_to_utf8_with_errors(const char16_t * buf, size_t len, char* utf8_buffer) const noexcept final;
1512   simdutf_warn_unused size_t convert_valid_utf16le_to_utf8(const char16_t * buf, size_t len, char* utf8_buffer) const noexcept final;
1513   simdutf_warn_unused size_t convert_valid_utf16be_to_utf8(const char16_t * buf, size_t len, char* utf8_buffer) const noexcept final;
1514   simdutf_warn_unused size_t convert_utf32_to_utf8(const char32_t * buf, size_t len, char* utf8_buffer) const noexcept final;
1515   simdutf_warn_unused result convert_utf32_to_utf8_with_errors(const char32_t * buf, size_t len, char* utf8_buffer) const noexcept final;
1516   simdutf_warn_unused size_t convert_valid_utf32_to_utf8(const char32_t * buf, size_t len, char* utf8_buffer) const noexcept final;
1517   simdutf_warn_unused size_t convert_utf32_to_latin1(const char32_t * buf, size_t len, char* latin1_output) const noexcept final;
1518   simdutf_warn_unused result convert_utf32_to_latin1_with_errors(const char32_t * buf, size_t len, char* latin1_output) const noexcept final;
1519   simdutf_warn_unused size_t convert_valid_utf32_to_latin1(const char32_t * buf, size_t len, char* latin1_output) const noexcept final;
1520   simdutf_warn_unused size_t convert_utf32_to_utf16le(const char32_t * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
1521   simdutf_warn_unused size_t convert_utf32_to_utf16be(const char32_t * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
1522   simdutf_warn_unused result convert_utf32_to_utf16le_with_errors(const char32_t * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
1523   simdutf_warn_unused result convert_utf32_to_utf16be_with_errors(const char32_t * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
1524   simdutf_warn_unused size_t convert_valid_utf32_to_utf16le(const char32_t * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
1525   simdutf_warn_unused size_t convert_valid_utf32_to_utf16be(const char32_t * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
1526   simdutf_warn_unused size_t convert_utf16le_to_utf32(const char16_t * buf, size_t len, char32_t* utf32_buffer) const noexcept final;
1527   simdutf_warn_unused size_t convert_utf16be_to_utf32(const char16_t * buf, size_t len, char32_t* utf32_buffer) const noexcept final;
1528   simdutf_warn_unused result convert_utf16le_to_utf32_with_errors(const char16_t * buf, size_t len, char32_t* utf32_buffer) const noexcept final;
1529   simdutf_warn_unused result convert_utf16be_to_utf32_with_errors(const char16_t * buf, size_t len, char32_t* utf32_buffer) const noexcept final;
1530   simdutf_warn_unused size_t convert_valid_utf16le_to_utf32(const char16_t * buf, size_t len, char32_t* utf32_buffer) const noexcept final;
1531   simdutf_warn_unused size_t convert_valid_utf16be_to_utf32(const char16_t * buf, size_t len, char32_t* utf32_buffer) const noexcept final;
2407   simdutf_warn_unused bool validate_utf8(const char *buf, size_t len) const noexcept final;
2408   simdutf_warn_unused result validate_utf8_with_errors(const char *buf, size_t len) const noexcept final;
2409   simdutf_warn_unused bool validate_ascii(const char *buf, size_t len) const noexcept final;
2410   simdutf_warn_unused result validate_ascii_with_errors(const char *buf, size_t len) const noexcept final;
2411   simdutf_warn_unused bool validate_utf16le(const char16_t *buf, size_t len) const noexcept final;
2412   simdutf_warn_unused bool validate_utf16be(const char16_t *buf, size_t len) const noexcept final;
2413   simdutf_warn_unused result validate_utf16le_with_errors(const char16_t *buf, size_t len) const noexcept final;
2414   simdutf_warn_unused result validate_utf16be_with_errors(const char16_t *buf, size_t len) const noexcept final;
2415   simdutf_warn_unused bool validate_utf32(const char32_t *buf, size_t len) const noexcept final;
2416   simdutf_warn_unused result validate_utf32_with_errors(const char32_t *buf, size_t len) const noexcept final;
2417   simdutf_warn_unused size_t convert_latin1_to_utf8(const char * buf, size_t len, char* utf8_output) const noexcept final;
2418   simdutf_warn_unused size_t convert_latin1_to_utf16le(const char * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
2419   simdutf_warn_unused size_t convert_latin1_to_utf16be(const char * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
2420   simdutf_warn_unused size_t convert_latin1_to_utf32(const char * buf, size_t len, char32_t* utf32_output) const noexcept final;
2421   simdutf_warn_unused size_t convert_utf8_to_latin1(const char * buf, size_t len, char* latin1_output) const noexcept final;
2422   simdutf_warn_unused result convert_utf8_to_latin1_with_errors(const char * buf, size_t len, char* latin1_buffer) const noexcept final;
2423   simdutf_warn_unused size_t convert_valid_utf8_to_latin1(const char * buf, size_t len, char* latin1_output) const noexcept final;
2424   simdutf_warn_unused size_t convert_utf8_to_utf16le(const char * buf, size_t len, char16_t* utf16_output) const noexcept final;
2425   simdutf_warn_unused size_t convert_utf8_to_utf16be(const char * buf, size_t len, char16_t* utf16_output) const noexcept final;
2426   simdutf_warn_unused result convert_utf8_to_utf16le_with_errors(const char * buf, size_t len, char16_t* utf16_output) const noexcept final;
2427   simdutf_warn_unused result convert_utf8_to_utf16be_with_errors(const char * buf, size_t len, char16_t* utf16_output) const noexcept final;
2428   simdutf_warn_unused size_t convert_valid_utf8_to_utf16le(const char * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
2429   simdutf_warn_unused size_t convert_valid_utf8_to_utf16be(const char * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
2430   simdutf_warn_unused size_t convert_utf8_to_utf32(const char * buf, size_t len, char32_t* utf32_output) const noexcept final;
2431   simdutf_warn_unused result convert_utf8_to_utf32_with_errors(const char * buf, size_t len, char32_t* utf32_output) const noexcept final;
2432   simdutf_warn_unused size_t convert_valid_utf8_to_utf32(const char * buf, size_t len, char32_t* utf32_buffer) const noexcept final;
2433   simdutf_warn_unused size_t convert_utf16le_to_latin1(const char16_t * buf, size_t len, char* latin1_buffer) const noexcept final;
2434   simdutf_warn_unused size_t convert_utf16be_to_latin1(const char16_t * buf, size_t len, char* latin1_buffer) const noexcept final;
2435   simdutf_warn_unused result convert_utf16le_to_latin1_with_errors(const char16_t * buf, size_t len, char* latin1_buffer) const noexcept final;
2436   simdutf_warn_unused result convert_utf16be_to_latin1_with_errors(const char16_t * buf, size_t len, char* latin1_buffer) const noexcept final;
2437   simdutf_warn_unused size_t convert_valid_utf16le_to_latin1(const char16_t * buf, size_t len, char* latin1_buffer) const noexcept final;
2438   simdutf_warn_unused size_t convert_valid_utf16be_to_latin1(const char16_t * buf, size_t len, char* latin1_buffer) const noexcept final;
2439   simdutf_warn_unused size_t convert_utf16le_to_utf8(const char16_t * buf, size_t len, char* utf8_buffer) const noexcept final;
2440   simdutf_warn_unused size_t convert_utf16be_to_utf8(const char16_t * buf, size_t len, char* utf8_buffer) const noexcept final;
2441   simdutf_warn_unused result convert_utf16le_to_utf8_with_errors(const char16_t * buf, size_t len, char* utf8_buffer) const noexcept final;
2442   simdutf_warn_unused result convert_utf16be_to_utf8_with_errors(const char16_t * buf, size_t len, char* utf8_buffer) const noexcept final;
2443   simdutf_warn_unused size_t convert_valid_utf16le_to_utf8(const char16_t * buf, size_t len, char* utf8_buffer) const noexcept final;
2444   simdutf_warn_unused size_t convert_valid_utf16be_to_utf8(const char16_t * buf, size_t len, char* utf8_buffer) const noexcept final;
2445   simdutf_warn_unused size_t convert_utf32_to_utf8(const char32_t * buf, size_t len, char* utf8_buffer) const noexcept final;
2446   simdutf_warn_unused result convert_utf32_to_utf8_with_errors(const char32_t * buf, size_t len, char* utf8_buffer) const noexcept final;
2447   simdutf_warn_unused size_t convert_valid_utf32_to_utf8(const char32_t * buf, size_t len, char* utf8_buffer) const noexcept final;
2448   simdutf_warn_unused size_t convert_utf32_to_latin1(const char32_t * buf, size_t len, char* latin1_output) const noexcept final;
2449   simdutf_warn_unused result convert_utf32_to_latin1_with_errors(const char32_t * buf, size_t len, char* latin1_output) const noexcept final;
2450   simdutf_warn_unused size_t convert_valid_utf32_to_latin1(const char32_t * buf, size_t len, char* latin1_output) const noexcept final;
2451   simdutf_warn_unused size_t convert_utf32_to_utf16le(const char32_t * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
2452   simdutf_warn_unused size_t convert_utf32_to_utf16be(const char32_t * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
2453   simdutf_warn_unused result convert_utf32_to_utf16le_with_errors(const char32_t * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
2454   simdutf_warn_unused result convert_utf32_to_utf16be_with_errors(const char32_t * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
2455   simdutf_warn_unused size_t convert_valid_utf32_to_utf16le(const char32_t * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
2456   simdutf_warn_unused size_t convert_valid_utf32_to_utf16be(const char32_t * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
2457   simdutf_warn_unused size_t convert_utf16le_to_utf32(const char16_t * buf, size_t len, char32_t* utf32_buffer) const noexcept final;
2458   simdutf_warn_unused size_t convert_utf16be_to_utf32(const char16_t * buf, size_t len, char32_t* utf32_buffer) const noexcept final;
2459   simdutf_warn_unused result convert_utf16le_to_utf32_with_errors(const char16_t * buf, size_t len, char32_t* utf32_buffer) const noexcept final;
2460   simdutf_warn_unused result convert_utf16be_to_utf32_with_errors(const char16_t * buf, size_t len, char32_t* utf32_buffer) const noexcept final;
2461   simdutf_warn_unused size_t convert_valid_utf16le_to_utf32(const char16_t * buf, size_t len, char32_t* utf32_buffer) const noexcept final;
2462   simdutf_warn_unused size_t convert_valid_utf16be_to_utf32(const char16_t * buf, size_t len, char32_t* utf32_buffer) const noexcept final;
3348   simdutf_warn_unused bool validate_utf8(const char *buf, size_t len) const noexcept final;
3349   simdutf_warn_unused result validate_utf8_with_errors(const char *buf, size_t len) const noexcept final;
3350   simdutf_warn_unused bool validate_ascii(const char *buf, size_t len) const noexcept final;
3351   simdutf_warn_unused result validate_ascii_with_errors(const char *buf, size_t len) const noexcept final;
3352   simdutf_warn_unused bool validate_utf16le(const char16_t *buf, size_t len) const noexcept final;
3353   simdutf_warn_unused bool validate_utf16be(const char16_t *buf, size_t len) const noexcept final;
3354   simdutf_warn_unused result validate_utf16le_with_errors(const char16_t *buf, size_t len) const noexcept final;
3355   simdutf_warn_unused result validate_utf16be_with_errors(const char16_t *buf, size_t len) const noexcept final;
3356   simdutf_warn_unused bool validate_utf32(const char32_t *buf, size_t len) const noexcept final;
3357   simdutf_warn_unused result validate_utf32_with_errors(const char32_t *buf, size_t len) const noexcept final;
3358   simdutf_warn_unused size_t convert_utf8_to_utf16le(const char * buf, size_t len, char16_t* utf16_output) const noexcept final;
3359   simdutf_warn_unused size_t convert_utf8_to_utf16be(const char * buf, size_t len, char16_t* utf16_output) const noexcept final;
3360   simdutf_warn_unused result convert_utf8_to_utf16le_with_errors(const char * buf, size_t len, char16_t* utf16_output) const noexcept final;
3361   simdutf_warn_unused result convert_utf8_to_utf16be_with_errors(const char * buf, size_t len, char16_t* utf16_output) const noexcept final;
3362   simdutf_warn_unused size_t convert_valid_utf8_to_utf16le(const char * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
3363   simdutf_warn_unused size_t convert_valid_utf8_to_utf16be(const char * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
3364   simdutf_warn_unused size_t convert_utf8_to_utf32(const char * buf, size_t len, char32_t* utf32_output) const noexcept final;
3365   simdutf_warn_unused result convert_utf8_to_utf32_with_errors(const char * buf, size_t len, char32_t* utf32_output) const noexcept final;
3366   simdutf_warn_unused size_t convert_valid_utf8_to_utf32(const char * buf, size_t len, char32_t* utf32_buffer) const noexcept final;
3367   simdutf_warn_unused size_t convert_utf16le_to_utf8(const char16_t * buf, size_t len, char* utf8_buffer) const noexcept final;
3368   simdutf_warn_unused size_t convert_utf16be_to_utf8(const char16_t * buf, size_t len, char* utf8_buffer) const noexcept final;
3369   simdutf_warn_unused result convert_utf16le_to_utf8_with_errors(const char16_t * buf, size_t len, char* utf8_buffer) const noexcept final;
3370   simdutf_warn_unused result convert_utf16be_to_utf8_with_errors(const char16_t * buf, size_t len, char* utf8_buffer) const noexcept final;
3371   simdutf_warn_unused size_t convert_valid_utf16le_to_utf8(const char16_t * buf, size_t len, char* utf8_buffer) const noexcept final;
3372   simdutf_warn_unused size_t convert_valid_utf16be_to_utf8(const char16_t * buf, size_t len, char* utf8_buffer) const noexcept final;
3373   simdutf_warn_unused size_t convert_utf32_to_utf8(const char32_t * buf, size_t len, char* utf8_buffer) const noexcept final;
3374   simdutf_warn_unused result convert_utf32_to_utf8_with_errors(const char32_t * buf, size_t len, char* utf8_buffer) const noexcept final;
3375   simdutf_warn_unused size_t convert_valid_utf32_to_utf8(const char32_t * buf, size_t len, char* utf8_buffer) const noexcept final;
3376   simdutf_warn_unused size_t convert_utf32_to_utf16le(const char32_t * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
3377   simdutf_warn_unused size_t convert_utf32_to_utf16be(const char32_t * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
3378   simdutf_warn_unused result convert_utf32_to_utf16le_with_errors(const char32_t * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
3379   simdutf_warn_unused result convert_utf32_to_utf16be_with_errors(const char32_t * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
3380   simdutf_warn_unused size_t convert_valid_utf32_to_utf16le(const char32_t * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
3381   simdutf_warn_unused size_t convert_valid_utf32_to_utf16be(const char32_t * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
3382   simdutf_warn_unused size_t convert_utf16le_to_utf32(const char16_t * buf, size_t len, char32_t* utf32_buffer) const noexcept final;
3383   simdutf_warn_unused size_t convert_utf16be_to_utf32(const char16_t * buf, size_t len, char32_t* utf32_buffer) const noexcept final;
3384   simdutf_warn_unused result convert_utf16le_to_utf32_with_errors(const char16_t * buf, size_t len, char32_t* utf32_buffer) const noexcept final;
3385   simdutf_warn_unused result convert_utf16be_to_utf32_with_errors(const char16_t * buf, size_t len, char32_t* utf32_buffer) const noexcept final;
3386   simdutf_warn_unused size_t convert_valid_utf16le_to_utf32(const char16_t * buf, size_t len, char32_t* utf32_buffer) const noexcept final;
3387   simdutf_warn_unused size_t convert_valid_utf16be_to_utf32(const char16_t * buf, size_t len, char32_t* utf32_buffer) const noexcept final;
4005   simdutf_warn_unused bool validate_utf8(const char *buf, size_t len) const noexcept final;
4006   simdutf_warn_unused result validate_utf8_with_errors(const char *buf, size_t len) const noexcept final;
4007   simdutf_warn_unused bool validate_ascii(const char *buf, size_t len) const noexcept final;
4008   simdutf_warn_unused result validate_ascii_with_errors(const char *buf, size_t len) const noexcept final;
4009   simdutf_warn_unused bool validate_utf16le(const char16_t *buf, size_t len) const noexcept final;
4010   simdutf_warn_unused bool validate_utf16be(const char16_t *buf, size_t len) const noexcept final;
4011   simdutf_warn_unused result validate_utf16le_with_errors(const char16_t *buf, size_t len) const noexcept final;
4012   simdutf_warn_unused result validate_utf16be_with_errors(const char16_t *buf, size_t len) const noexcept final;
4013   simdutf_warn_unused bool validate_utf32(const char32_t *buf, size_t len) const noexcept final;
4014   simdutf_warn_unused result validate_utf32_with_errors(const char32_t *buf, size_t len) const noexcept final;
4015   simdutf_warn_unused size_t convert_latin1_to_utf8(const char * buf, size_t len, char* utf8_output) const noexcept final;
4016   simdutf_warn_unused size_t convert_latin1_to_utf16le(const char * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
4017   simdutf_warn_unused size_t convert_latin1_to_utf16be(const char * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
4018   simdutf_warn_unused size_t convert_latin1_to_utf32(const char * buf, size_t len, char32_t* utf32_output) const noexcept final;
4019   simdutf_warn_unused size_t convert_utf8_to_latin1(const char * buf, size_t len, char* latin1_output) const noexcept final;
4020   simdutf_warn_unused result convert_utf8_to_latin1_with_errors(const char * buf, size_t len, char* latin1_buffer) const noexcept final;
4021   simdutf_warn_unused size_t convert_valid_utf8_to_latin1(const char * buf, size_t len, char* latin1_output) const noexcept final;
4022   simdutf_warn_unused size_t convert_utf8_to_utf16le(const char * buf, size_t len, char16_t* utf16_output) const noexcept final;
4023   simdutf_warn_unused size_t convert_utf8_to_utf16be(const char * buf, size_t len, char16_t* utf16_output) const noexcept final;
4024   simdutf_warn_unused result convert_utf8_to_utf16le_with_errors(const char * buf, size_t len, char16_t* utf16_output) const noexcept final;
4025   simdutf_warn_unused result convert_utf8_to_utf16be_with_errors(const char * buf, size_t len, char16_t* utf16_output) const noexcept final;
4026   simdutf_warn_unused size_t convert_valid_utf8_to_utf16le(const char * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
4027   simdutf_warn_unused size_t convert_valid_utf8_to_utf16be(const char * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
4028   simdutf_warn_unused size_t convert_utf8_to_utf32(const char * buf, size_t len, char32_t* utf32_output) const noexcept final;
4029   simdutf_warn_unused result convert_utf8_to_utf32_with_errors(const char * buf, size_t len, char32_t* utf32_output) const noexcept final;
4030   simdutf_warn_unused size_t convert_valid_utf8_to_utf32(const char * buf, size_t len, char32_t* utf32_buffer) const noexcept final;
4031   simdutf_warn_unused size_t convert_utf16le_to_latin1(const char16_t * buf, size_t len, char* latin1_buffer) const noexcept final;
4032   simdutf_warn_unused size_t convert_utf16be_to_latin1(const char16_t * buf, size_t len, char* latin1_buffer) const noexcept final;
4033   simdutf_warn_unused result convert_utf16le_to_latin1_with_errors(const char16_t * buf, size_t len, char* latin1_buffer) const noexcept final;
4034   simdutf_warn_unused result convert_utf16be_to_latin1_with_errors(const char16_t * buf, size_t len, char* latin1_buffer) const noexcept final;
4035   simdutf_warn_unused size_t convert_valid_utf16le_to_latin1(const char16_t * buf, size_t len, char* latin1_buffer) const noexcept final;
4036   simdutf_warn_unused size_t convert_valid_utf16be_to_latin1(const char16_t * buf, size_t len, char* latin1_buffer) const noexcept final;
4037   simdutf_warn_unused size_t convert_utf16le_to_utf8(const char16_t * buf, size_t len, char* utf8_buffer) const noexcept final;
4038   simdutf_warn_unused size_t convert_utf16be_to_utf8(const char16_t * buf, size_t len, char* utf8_buffer) const noexcept final;
4039   simdutf_warn_unused result convert_utf16le_to_utf8_with_errors(const char16_t * buf, size_t len, char* utf8_buffer) const noexcept final;
4040   simdutf_warn_unused result convert_utf16be_to_utf8_with_errors(const char16_t * buf, size_t len, char* utf8_buffer) const noexcept final;
4041   simdutf_warn_unused size_t convert_valid_utf16le_to_utf8(const char16_t * buf, size_t len, char* utf8_buffer) const noexcept final;
4042   simdutf_warn_unused size_t convert_valid_utf16be_to_utf8(const char16_t * buf, size_t len, char* utf8_buffer) const noexcept final;
4043   simdutf_warn_unused size_t convert_utf32_to_utf8(const char32_t * buf, size_t len, char* utf8_buffer) const noexcept final;
4044   simdutf_warn_unused result convert_utf32_to_utf8_with_errors(const char32_t * buf, size_t len, char* utf8_buffer) const noexcept final;
4045   simdutf_warn_unused size_t convert_valid_utf32_to_utf8(const char32_t * buf, size_t len, char* utf8_buffer) const noexcept final;
4046   simdutf_warn_unused size_t convert_utf32_to_latin1(const char32_t * buf, size_t len, char* latin1_output) const noexcept final;
4047   simdutf_warn_unused result convert_utf32_to_latin1_with_errors(const char32_t * buf, size_t len, char* latin1_output) const noexcept final;
4048   simdutf_warn_unused size_t convert_valid_utf32_to_latin1(const char32_t * buf, size_t len, char* latin1_output) const noexcept final;
4049   simdutf_warn_unused size_t convert_utf32_to_utf16le(const char32_t * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
4050   simdutf_warn_unused size_t convert_utf32_to_utf16be(const char32_t * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
4051   simdutf_warn_unused result convert_utf32_to_utf16le_with_errors(const char32_t * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
4052   simdutf_warn_unused result convert_utf32_to_utf16be_with_errors(const char32_t * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
4053   simdutf_warn_unused size_t convert_valid_utf32_to_utf16le(const char32_t * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
4054   simdutf_warn_unused size_t convert_valid_utf32_to_utf16be(const char32_t * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
4055   simdutf_warn_unused size_t convert_utf16le_to_utf32(const char16_t * buf, size_t len, char32_t* utf32_buffer) const noexcept final;
4056   simdutf_warn_unused size_t convert_utf16be_to_utf32(const char16_t * buf, size_t len, char32_t* utf32_buffer) const noexcept final;
4057   simdutf_warn_unused result convert_utf16le_to_utf32_with_errors(const char16_t * buf, size_t len, char32_t* utf32_buffer) const noexcept final;
4058   simdutf_warn_unused result convert_utf16be_to_utf32_with_errors(const char16_t * buf, size_t len, char32_t* utf32_buffer) const noexcept final;
4059   simdutf_warn_unused size_t convert_valid_utf16le_to_utf32(const char16_t * buf, size_t len, char32_t* utf32_buffer) const noexcept final;
4060   simdutf_warn_unused size_t convert_valid_utf16be_to_utf32(const char16_t * buf, size_t len, char32_t* utf32_buffer) const noexcept final;
4127 inline simdutf_warn_unused bool validate(const char *buf, size_t len) noexcept {
4131   while (pos < len) {
4134     if (next_pos <= len) { // if it is safe to read 16 more bytes, check that they are ascii
4148       if (++pos == len) { return true; }
4154       if (next_pos > len) { return false; }
4161       if (next_pos > len) { return false; }
4174       if (next_pos > len) { return false; }
4193 inline simdutf_warn_unused result validate_with_errors(const char *buf, size_t len) noexcept {
4197   while (pos < len) {
4200     if (next_pos <= len) { // if it is safe to read 16 more bytes, check that they are ascii
4214       if (++pos == len) { return result(error_code::SUCCESS, len); }
4220       if (next_pos > len) { return result(error_code::TOO_SHORT, pos); }
4227       if (next_pos > len) { return result(error_code::TOO_SHORT, pos); }
4238       if (next_pos > len) { return result(error_code::TOO_SHORT, pos); }
4255   return result(error_code::SUCCESS, len);
4262 inline simdutf_warn_unused result rewind_and_validate_with_errors(const char *start, const char *buf, size_t len) noexcept {
4279   result res = validate_with_errors(buf, len + extra_len);
4284 inline size_t count_code_points(const char* buf, size_t len) {
4287     for(size_t i = 0; i < len; i++) {
4294 inline size_t utf16_length_from_utf8(const char* buf, size_t len) {
4297     for(size_t i = 0; i < len; i++) {
4345 inline simdutf_warn_unused bool validate(const char16_t *buf, size_t len) noexcept {
4348   while (pos < len) {
4351         if(pos + 1 >= len) { return false; }
4366 inline simdutf_warn_unused result validate_with_errors(const char16_t *buf, size_t len) noexcept {
4369   while (pos < len) {
4372         if(pos + 1 >= len) { return result(error_code::SURROGATE, pos); }
4387 inline size_t count_code_points(const char16_t* buf, size_t len) {
4391   for(size_t i = 0; i < len; i++) {
4399 inline size_t utf8_length_from_utf16(const char16_t* buf, size_t len) {
4403   for(size_t i = 0; i < len; i++) {
4413 inline size_t utf32_length_from_utf16(const char16_t* buf, size_t len) {
4417   for(size_t i = 0; i < len; i++) {
4425 inline size_t latin1_length_from_utf16(size_t len) {
4426   return len;
4544   simdutf_warn_unused bool validate_utf8(const char * buf, size_t len) const noexcept final override {
4545     return set_best()->validate_utf8(buf, len);
4548   simdutf_warn_unused result validate_utf8_with_errors(const char * buf, size_t len) const noexcept final override {
4549     return set_best()->validate_utf8_with_errors(buf, len);
4552   simdutf_warn_unused bool validate_ascii(const char * buf, size_t len) const noexcept final override {
4553     return set_best()->validate_ascii(buf, len);
4556   simdutf_warn_unused result validate_ascii_with_errors(const char * buf, size_t len) const noexcept final override {
4557     return set_best()->validate_ascii_with_errors(buf, len);
4560   simdutf_warn_unused bool validate_utf16le(const char16_t * buf, size_t len) const noexcept final override {
4561     return set_best()->validate_utf16le(buf, len);
4564   simdutf_warn_unused bool validate_utf16be(const char16_t * buf, size_t len) const noexcept final override {
4565     return set_best()->validate_utf16be(buf, len);
4568   simdutf_warn_unused result validate_utf16le_with_errors(const char16_t * buf, size_t len) const noexcept final override {
4569     return set_best()->validate_utf16le_with_errors(buf, len);
4572   simdutf_warn_unused result validate_utf16be_with_errors(const char16_t * buf, size_t len) const noexcept final override {
4573     return set_best()->validate_utf16be_with_errors(buf, len);
4576   simdutf_warn_unused bool validate_utf32(const char32_t * buf, size_t len) const noexcept final override {
4577     return set_best()->validate_utf32(buf, len);
4580   simdutf_warn_unused result validate_utf32_with_errors(const char32_t * buf, size_t len) const noexcept final override {
4581     return set_best()->validate_utf32_with_errors(buf, len);
4584   simdutf_warn_unused size_t convert_latin1_to_utf8(const char * buf, size_t len, char* utf8_output) const noexcept final override {
4585     return set_best()->convert_latin1_to_utf8(buf, len,utf8_output);
4588   simdutf_warn_unused size_t convert_latin1_to_utf16le(const char * buf, size_t len, char16_t* utf16_output) const noexcept final override {
4589     return set_best()->convert_latin1_to_utf16le(buf, len, utf16_output);
4592   simdutf_warn_unused size_t convert_latin1_to_utf16be(const char * buf, size_t len, char16_t* utf16_output) const noexcept final override {
4593     return set_best()->convert_latin1_to_utf16be(buf, len, utf16_output);
4596   simdutf_warn_unused size_t convert_latin1_to_utf32(const char * buf, size_t len, char32_t * latin1_output) const noexcept final override {
4597     return set_best()->convert_latin1_to_utf32(buf, len,latin1_output);
4600   simdutf_warn_unused size_t convert_utf8_to_latin1(const char * buf, size_t len, char* latin1_output) const noexcept final override {
4601     return set_best()->convert_utf8_to_latin1(buf, len,latin1_output);
4604   simdutf_warn_unused result convert_utf8_to_latin1_with_errors(const char* buf, size_t len, char* latin1_output) const noexcept  final override {
4605   return set_best()->convert_utf8_to_latin1_with_errors(buf, len, latin1_output);
4608   simdutf_warn_unused size_t convert_valid_utf8_to_latin1(const char * buf, size_t len, char* latin1_output) const noexcept final override {
4609     return set_best()->convert_valid_utf8_to_latin1(buf, len,latin1_output);
4612   simdutf_warn_unused size_t convert_utf8_to_utf16le(const char * buf, size_t len, char16_t* utf16_output) const noexcept final override {
4613     return set_best()->convert_utf8_to_utf16le(buf, len, utf16_output);
4616   simdutf_warn_unused size_t convert_utf8_to_utf16be(const char * buf, size_t len, char16_t* utf16_output) const noexcept final override {
4617     return set_best()->convert_utf8_to_utf16be(buf, len, utf16_output);
4620   simdutf_warn_unused result convert_utf8_to_utf16le_with_errors(const char * buf, size_t len, char16_t* utf16_output) const noexcept final override {
4621     return set_best()->convert_utf8_to_utf16le_with_errors(buf, len, utf16_output);
4624   simdutf_warn_unused result convert_utf8_to_utf16be_with_errors(const char * buf, size_t len, char16_t* utf16_output) const noexcept final override {
4625     return set_best()->convert_utf8_to_utf16be_with_errors(buf, len, utf16_output);
4628   simdutf_warn_unused size_t convert_valid_utf8_to_utf16le(const char * buf, size_t len, char16_t* utf16_output) const noexcept final override {
4629     return set_best()->convert_valid_utf8_to_utf16le(buf, len, utf16_output);
4632   simdutf_warn_unused size_t convert_valid_utf8_to_utf16be(const char * buf, size_t len, char16_t* utf16_output) const noexcept final override {
4633     return set_best()->convert_valid_utf8_to_utf16be(buf, len, utf16_output);
4636   simdutf_warn_unused size_t convert_utf8_to_utf32(const char * buf, size_t len, char32_t* utf32_output) const noexcept final override {
4637     return set_best()->convert_utf8_to_utf32(buf, len, utf32_output);
4640   simdutf_warn_unused result convert_utf8_to_utf32_with_errors(const char * buf, size_t len, char32_t* utf32_output) const noexcept final override {
4641     return set_best()->convert_utf8_to_utf32_with_errors(buf, len, utf32_output);
4644   simdutf_warn_unused size_t convert_valid_utf8_to_utf32(const char * buf, size_t len, char32_t* utf32_output) const noexcept final override {
4645     return set_best()->convert_valid_utf8_to_utf32(buf, len, utf32_output);
4648   simdutf_warn_unused size_t convert_utf16le_to_latin1(const char16_t * buf, size_t len, char* latin1_output) const noexcept final override {
4649     return set_best()->convert_utf16le_to_latin1(buf, len, latin1_output);
4652   simdutf_warn_unused size_t convert_utf16be_to_latin1(const char16_t * buf, size_t len, char* latin1_output) const noexcept final override {
4653     return set_best()->convert_utf16be_to_latin1(buf, len, latin1_output);
4656   simdutf_warn_unused result convert_utf16le_to_latin1_with_errors(const char16_t * buf, size_t len, char* latin1_output) const noexcept final override {
4657     return set_best()->convert_utf16le_to_latin1_with_errors(buf, len, latin1_output);
4660   simdutf_warn_unused result convert_utf16be_to_latin1_with_errors(const char16_t * buf, size_t len, char* latin1_output) const noexcept final override {
4661     return set_best()->convert_utf16be_to_latin1_with_errors(buf, len, latin1_output);
4664   simdutf_warn_unused size_t convert_valid_utf16le_to_latin1(const char16_t * buf, size_t len, char* latin1_output) const noexcept final override {
4665     return set_best()->convert_valid_utf16le_to_latin1(buf, len, latin1_output);
4668   simdutf_warn_unused size_t convert_valid_utf16be_to_latin1(const char16_t * buf, size_t len, char* latin1_output) const noexcept final override {
4669     return set_best()->convert_valid_utf16be_to_latin1(buf, len, latin1_output);
4672   simdutf_warn_unused size_t convert_utf16le_to_utf8(const char16_t * buf, size_t len, char* utf8_output) const noexcept final override {
4673     return set_best()->convert_utf16le_to_utf8(buf, len, utf8_output);
4676   simdutf_warn_unused size_t convert_utf16be_to_utf8(const char16_t * buf, size_t len, char* utf8_output) const noexcept final override {
4677     return set_best()->convert_utf16be_to_utf8(buf, len, utf8_output);
4680   simdutf_warn_unused result convert_utf16le_to_utf8_with_errors(const char16_t * buf, size_t len, char* utf8_output) const noexcept final override {
4681     return set_best()->convert_utf16le_to_utf8_with_errors(buf, len, utf8_output);
4684   simdutf_warn_unused result convert_utf16be_to_utf8_with_errors(const char16_t * buf, size_t len, char* utf8_output) const noexcept final override {
4685     return set_best()->convert_utf16be_to_utf8_with_errors(buf, len, utf8_output);
4688   simdutf_warn_unused size_t convert_valid_utf16le_to_utf8(const char16_t * buf, size_t len, char* utf8_output) const noexcept final override {
4689     return set_best()->convert_valid_utf16le_to_utf8(buf, len, utf8_output);
4692   simdutf_warn_unused size_t convert_valid_utf16be_to_utf8(const char16_t * buf, size_t len, char* utf8_output) const noexcept final override {
4693     return set_best()->convert_valid_utf16be_to_utf8(buf, len, utf8_output);
4696   simdutf_warn_unused size_t convert_utf32_to_latin1(const char32_t * buf, size_t len, char* latin1_output) const noexcept final override {
4697     return set_best()->convert_utf32_to_latin1(buf, len,latin1_output);
4700   simdutf_warn_unused result convert_utf32_to_latin1_with_errors(const char32_t * buf, size_t len, char* latin1_output) const noexcept final override {
4701     return set_best()->convert_utf32_to_latin1_with_errors(buf, len,latin1_output);
4704   simdutf_warn_unused size_t convert_valid_utf32_to_latin1(const char32_t * buf, size_t len, char* latin1_output) const noexcept final override {
4705     return set_best()->convert_utf32_to_latin1(buf, len,latin1_output);
4708   simdutf_warn_unused size_t convert_utf32_to_utf8(const char32_t * buf, size_t len, char* utf8_output) const noexcept final override {
4709     return set_best()->convert_utf32_to_utf8(buf, len, utf8_output);
4712   simdutf_warn_unused result convert_utf32_to_utf8_with_errors(const char32_t * buf, size_t len, char* utf8_output) const noexcept final override {
4713     return set_best()->convert_utf32_to_utf8_with_errors(buf, len, utf8_output);
4716   simdutf_warn_unused size_t convert_valid_utf32_to_utf8(const char32_t * buf, size_t len, char* utf8_output) const noexcept final override {
4717     return set_best()->convert_valid_utf32_to_utf8(buf, len, utf8_output);
4720   simdutf_warn_unused size_t convert_utf32_to_utf16le(const char32_t * buf, size_t len, char16_t* utf16_output) const noexcept final override {
4721     return set_best()->convert_utf32_to_utf16le(buf, len, utf16_output);
4724   simdutf_warn_unused size_t convert_utf32_to_utf16be(const char32_t * buf, size_t len, char16_t* utf16_output) const noexcept final override {
4725     return set_best()->convert_utf32_to_utf16be(buf, len, utf16_output);
4728   simdutf_warn_unused result convert_utf32_to_utf16le_with_errors(const char32_t * buf, size_t len, char16_t* utf16_output) const noexcept final override {
4729     return set_best()->convert_utf32_to_utf16le_with_errors(buf, len, utf16_output);
4732   simdutf_warn_unused result convert_utf32_to_utf16be_with_errors(const char32_t * buf, size_t len, char16_t* utf16_output) const noexcept final override {
4733     return set_best()->convert_utf32_to_utf16be_with_errors(buf, len, utf16_output);
4736   simdutf_warn_unused size_t convert_valid_utf32_to_utf16le(const char32_t * buf, size_t len, char16_t* utf16_output) const noexcept final override {
4737     return set_best()->convert_valid_utf32_to_utf16le(buf, len, utf16_output);
4740   simdutf_warn_unused size_t convert_valid_utf32_to_utf16be(const char32_t * buf, size_t len, char16_t* utf16_output) const noexcept final override {
4741     return set_best()->convert_valid_utf32_to_utf16be(buf, len, utf16_output);
4744   simdutf_warn_unused size_t convert_utf16le_to_utf32(const char16_t * buf, size_t len, char32_t* utf32_output) const noexcept final override {
4745     return set_best()->convert_utf16le_to_utf32(buf, len, utf32_output);
4748   simdutf_warn_unused size_t convert_utf16be_to_utf32(const char16_t * buf, size_t len, char32_t* utf32_output) const noexcept final override {
4749     return set_best()->convert_utf16be_to_utf32(buf, len, utf32_output);
4752   simdutf_warn_unused result convert_utf16le_to_utf32_with_errors(const char16_t * buf, size_t len, char32_t* utf32_output) const noexcept final override {
4753     return set_best()->convert_utf16le_to_utf32_with_errors(buf, len, utf32_output);
4756   simdutf_warn_unused result convert_utf16be_to_utf32_with_errors(const char16_t * buf, size_t len, char32_t* utf32_output) const noexcept final override {
4757     return set_best()->convert_utf16be_to_utf32_with_errors(buf, len, utf32_output);
4760   simdutf_warn_unused size_t convert_valid_utf16le_to_utf32(const char16_t * buf, size_t len, char32_t* utf32_output) const noexcept final override {
4761     return set_best()->convert_valid_utf16le_to_utf32(buf, len, utf32_output);
4764   simdutf_warn_unused size_t convert_valid_utf16be_to_utf32(const char16_t * buf, size_t len, char32_t* utf32_output) const noexcept final override {
4765     return set_best()->convert_valid_utf16be_to_utf32(buf, len, utf32_output);
4768   void change_endianness_utf16(const char16_t * buf, size_t len, char16_t * output) const noexcept final override {
4769     set_best()->change_endianness_utf16(buf, len, output);
4772   simdutf_warn_unused size_t count_utf16le(const char16_t * buf, size_t len) const noexcept final override {
4773     return set_best()->count_utf16le(buf, len);
4776   simdutf_warn_unused size_t count_utf16be(const char16_t * buf, size_t len) const noexcept final override {
4777     return set_best()->count_utf16be(buf, len);
4780   simdutf_warn_unused size_t count_utf8(const char * buf, size_t len) const noexcept final override {
4781     return set_best()->count_utf8(buf, len);
4784   simdutf_warn_unused size_t latin1_length_from_utf8(const char * buf, size_t len) const noexcept override {
4785     return set_best()->latin1_length_from_utf8(buf, len);
4788   simdutf_warn_unused size_t latin1_length_from_utf16(size_t len) const noexcept override {
4789     return set_best()->latin1_length_from_utf16(len);
4792   simdutf_warn_unused size_t latin1_length_from_utf32(size_t len) const noexcept override {
4793     return set_best()->latin1_length_from_utf32(len);
4796   simdutf_warn_unused size_t utf8_length_from_latin1(const char * buf, size_t len) const noexcept override {
4797     return set_best()->utf8_length_from_latin1(buf, len);
4800   simdutf_warn_unused size_t utf8_length_from_utf16le(const char16_t * buf, size_t len) const noexcept override {
4801     return set_best()->utf8_length_from_utf16le(buf, len);
4804   simdutf_warn_unused size_t utf8_length_from_utf16be(const char16_t * buf, size_t len) const noexcept override {
4805     return set_best()->utf8_length_from_utf16be(buf, len);
4808   simdutf_warn_unused size_t utf16_length_from_latin1(size_t len) const noexcept override {
4809     return set_best()->utf16_length_from_latin1(len);
4812   simdutf_warn_unused size_t utf32_length_from_latin1(size_t len) const noexcept override {
4813     return set_best()->utf32_length_from_latin1(len);
4816   simdutf_warn_unused size_t utf32_length_from_utf16le(const char16_t * buf, size_t len) const noexcept override {
4817     return set_best()->utf32_length_from_utf16le(buf, len);
4820   simdutf_warn_unused size_t utf32_length_from_utf16be(const char16_t * buf, size_t len) const noexcept override {
4821     return set_best()->utf32_length_from_utf16be(buf, len);
4824   simdutf_warn_unused size_t utf16_length_from_utf8(const char * buf, size_t len) const noexcept override {
4825     return set_best()->utf16_length_from_utf8(buf, len);
4828   simdutf_warn_unused size_t utf8_length_from_utf32(const char32_t * buf, size_t len) const noexcept override {
4829     return set_best()->utf8_length_from_utf32(buf, len);
4832   simdutf_warn_unused size_t utf16_length_from_utf32(const char32_t * buf, size_t len) const noexcept override {
4833     return set_best()->utf16_length_from_utf32(buf, len);
4836   simdutf_warn_unused size_t utf32_length_from_utf8(const char * buf, size_t len) const noexcept override {
4837     return set_best()->utf32_length_from_utf8(buf, len);
5240 simdutf_warn_unused bool validate_utf8(const char *buf, size_t len) noexcept {
5241   return get_active_implementation()->validate_utf8(buf, len);
5243 simdutf_warn_unused result validate_utf8_with_errors(const char *buf, size_t len) noexcept {
5244   return get_active_implementation()->validate_utf8_with_errors(buf, len);
5246 simdutf_warn_unused bool validate_ascii(const char *buf, size_t len) noexcept {
5247   return get_active_implementation()->validate_ascii(buf, len);
5249 simdutf_warn_unused result validate_ascii_with_errors(const char *buf, size_t len) noexcept {
5250   return get_active_implementation()->validate_ascii_with_errors(buf, len);
5259 simdutf_warn_unused size_t convert_latin1_to_utf8(const char * buf, size_t len, char* utf8_output) noexcept {
5260   return get_active_implementation()->convert_latin1_to_utf8(buf, len,utf8_output);
5262 simdutf_warn_unused size_t convert_latin1_to_utf16le(const char * buf, size_t len, char16_t* utf16_output) noexcept {
5263   return get_active_implementation()->convert_latin1_to_utf16le(buf, len, utf16_output);
5265 simdutf_warn_unused size_t convert_latin1_to_utf16be(const char * buf, size_t len, char16_t* utf16_output) noexcept{
5266   return get_active_implementation()->convert_latin1_to_utf16be(buf, len, utf16_output);
5268 simdutf_warn_unused size_t convert_latin1_to_utf32(const char * buf, size_t len, char32_t * latin1_output) noexcept {
5269   return get_active_implementation()->convert_latin1_to_utf32(buf, len,latin1_output);
5271 simdutf_warn_unused size_t convert_utf8_to_latin1(const char * buf, size_t len, char* latin1_output) noexcept {
5272   return get_active_implementation()->convert_utf8_to_latin1(buf, len,latin1_output);
5274 simdutf_warn_unused result convert_utf8_to_latin1_with_errors(const char* buf, size_t len, char* latin1_output) noexcept {
5275   return get_active_implementation()->convert_utf8_to_latin1_with_errors(buf, len, latin1_output);
5277 simdutf_warn_unused size_t convert_valid_utf8_to_latin1(const char * buf, size_t len, char* latin1_output) noexcept {
5278   return get_active_implementation()->convert_valid_utf8_to_latin1(buf, len,latin1_output);
5305 simdutf_warn_unused bool validate_utf16(const char16_t * buf, size_t len) noexcept {
5307   return validate_utf16be(buf, len);
5309   return validate_utf16le(buf, len);
5312 simdutf_warn_unused bool validate_utf16le(const char16_t * buf, size_t len) noexcept {
5313   return get_active_implementation()->validate_utf16le(buf, len);
5315 simdutf_warn_unused bool validate_utf16be(const char16_t * buf, size_t len) noexcept {
5316   return get_active_implementation()->validate_utf16be(buf, len);
5318 simdutf_warn_unused result validate_utf16_with_errors(const char16_t * buf, size_t len) noexcept {
5320   return validate_utf16be_with_errors(buf, len);
5322   return validate_utf16le_with_errors(buf, len);
5325 simdutf_warn_unused result validate_utf16le_with_errors(const char16_t * buf, size_t len) noexcept {
5326   return get_active_implementation()->validate_utf16le_with_errors(buf, len);
5328 simdutf_warn_unused result validate_utf16be_with_errors(const char16_t * buf, size_t len) noexcept {
5329   return get_active_implementation()->validate_utf16be_with_errors(buf, len);
5331 simdutf_warn_unused bool validate_utf32(const char32_t * buf, size_t len) noexcept {
5332   return get_active_implementation()->validate_utf32(buf, len);
5334 simdutf_warn_unused result validate_utf32_with_errors(const char32_t * buf, size_t len) noexcept {
5335   return get_active_implementation()->validate_utf32_with_errors(buf, len);
5353 simdutf_warn_unused size_t convert_utf16_to_utf8(const char16_t * buf, size_t len, char* utf8_buffer) noexcept {
5355   return convert_utf16be_to_utf8(buf, len, utf8_buffer);
5357   return convert_utf16le_to_utf8(buf, len, utf8_buffer);
5360 simdutf_warn_unused size_t convert_utf16_to_latin1(const char16_t * buf, size_t len, char* latin1_buffer) noexcept {
5362   return convert_utf16be_to_latin1(buf, len, latin1_buffer);
5364   return convert_utf16le_to_latin1(buf, len, latin1_buffer);
5367 simdutf_warn_unused size_t convert_latin1_to_utf16(const char * buf, size_t len, char16_t* utf16_output) noexcept {
5369   return convert_latin1_to_utf16be(buf, len, utf16_output);
5371   return convert_latin1_to_utf16le(buf, len, utf16_output);
5374 simdutf_warn_unused size_t convert_utf16be_to_latin1(const char16_t * buf, size_t len, char* latin1_buffer) noexcept {
5375   return get_active_implementation()->convert_utf16be_to_latin1(buf, len, latin1_buffer);
5377 simdutf_warn_unused size_t convert_utf16le_to_latin1(const char16_t * buf, size_t len, char* latin1_buffer) noexcept {
5378   return get_active_implementation()->convert_utf16le_to_latin1(buf, len, latin1_buffer);
5380 simdutf_warn_unused size_t convert_valid_utf16be_to_latin1(const char16_t * buf, size_t len, char* latin1_buffer) noexcept {
5381   return get_active_implementation()->convert_valid_utf16be_to_latin1(buf, len, latin1_buffer);
5383 simdutf_warn_unused size_t convert_valid_utf16le_to_latin1(const char16_t * buf, size_t len, char* latin1_buffer) noexcept {
5384   return get_active_implementation()->convert_valid_utf16le_to_latin1(buf, len, latin1_buffer);
5386 simdutf_warn_unused result convert_utf16le_to_latin1_with_errors(const char16_t * buf, size_t len, char* latin1_buffer) noexcept {
5387   return get_active_implementation()->convert_utf16le_to_latin1_with_errors(buf, len, latin1_buffer);
5389 simdutf_warn_unused result convert_utf16be_to_latin1_with_errors(const char16_t * buf, size_t len, char* latin1_buffer) noexcept {
5390   return get_active_implementation()->convert_utf16be_to_latin1_with_errors(buf, len, latin1_buffer);
5392 simdutf_warn_unused size_t convert_utf16le_to_utf8(const char16_t * buf, size_t len, char* utf8_buffer) noexcept {
5393   return get_active_implementation()->convert_utf16le_to_utf8(buf, len, utf8_buffer);
5395 simdutf_warn_unused size_t convert_utf16be_to_utf8(const char16_t * buf, size_t len, char* utf8_buffer) noexcept {
5396   return get_active_implementation()->convert_utf16be_to_utf8(buf, len, utf8_buffer);
5398 simdutf_warn_unused result convert_utf16_to_utf8_with_errors(const char16_t * buf, size_t len, char* utf8_buffer) noexcept {
5400   return convert_utf16be_to_utf8_with_errors(buf, len, utf8_buffer);
5402   return convert_utf16le_to_utf8_with_errors(buf, len, utf8_buffer);
5405 simdutf_warn_unused result convert_utf16_to_latin1_with_errors(const char16_t * buf, size_t len, char* latin1_buffer) noexcept {
5407   return convert_utf16be_to_latin1_with_errors(buf, len, latin1_buffer);
5409   return convert_utf16le_to_latin1_with_errors(buf, len, latin1_buffer);
5412 simdutf_warn_unused result convert_utf16le_to_utf8_with_errors(const char16_t * buf, size_t len, char* utf8_buffer) noexcept {
5413   return get_active_implementation()->convert_utf16le_to_utf8_with_errors(buf, len, utf8_buffer);
5415 simdutf_warn_unused result convert_utf16be_to_utf8_with_errors(const char16_t * buf, size_t len, char* utf8_buffer) noexcept {
5416   return get_active_implementation()->convert_utf16be_to_utf8_with_errors(buf, len, utf8_buffer);
5418 simdutf_warn_unused size_t convert_valid_utf16_to_utf8(const char16_t * buf, size_t len, char* utf8_buffer) noexcept {
5420   return convert_valid_utf16be_to_utf8(buf, len, utf8_buffer);
5422   return convert_valid_utf16le_to_utf8(buf, len, utf8_buffer);
5425 simdutf_warn_unused size_t convert_valid_utf16_to_latin1(const char16_t * buf, size_t len, char* latin1_buffer) noexcept {
5427   return convert_valid_utf16be_to_latin1(buf, len, latin1_buffer);
5429   return convert_valid_utf16le_to_latin1(buf, len, latin1_buffer);
5432 simdutf_warn_unused size_t convert_valid_utf16le_to_utf8(const char16_t * buf, size_t len, char* utf8_buffer) noexcept {
5433   return get_active_implementation()->convert_valid_utf16le_to_utf8(buf, len, utf8_buffer);
5435 simdutf_warn_unused size_t convert_valid_utf16be_to_utf8(const char16_t * buf, size_t len, char* utf8_buffer) noexcept {
5436   return get_active_implementation()->convert_valid_utf16be_to_utf8(buf, len, utf8_buffer);
5438 simdutf_warn_unused size_t convert_utf32_to_utf8(const char32_t * buf, size_t len, char* utf8_buffer) noexcept {
5439   return get_active_implementation()->convert_utf32_to_utf8(buf, len, utf8_buffer);
5441 simdutf_warn_unused result convert_utf32_to_utf8_with_errors(const char32_t * buf, size_t len, char* utf8_buffer) noexcept {
5442   return get_active_implementation()->convert_utf32_to_utf8_with_errors(buf, len, utf8_buffer);
5444 simdutf_warn_unused size_t convert_valid_utf32_to_utf8(const char32_t * buf, size_t len, char* utf8_buffer) noexcept {
5445   return get_active_implementation()->convert_valid_utf32_to_utf8(buf, len, utf8_buffer);
5447 simdutf_warn_unused size_t convert_utf32_to_utf16(const char32_t * buf, size_t len, char16_t* utf16_buffer) noexcept {
5449   return convert_utf32_to_utf16be(buf, len, utf16_buffer);
5451   return convert_utf32_to_utf16le(buf, len, utf16_buffer);
5457 simdutf_warn_unused size_t convert_utf32_to_utf16le(const char32_t * buf, size_t len, char16_t* utf16_buffer) noexcept {
5458   return get_active_implementation()->convert_utf32_to_utf16le(buf, len, utf16_buffer);
5460 simdutf_warn_unused size_t convert_utf32_to_utf16be(const char32_t * buf, size_t len, char16_t* utf16_buffer) noexcept {
5461   return get_active_implementation()->convert_utf32_to_utf16be(buf, len, utf16_buffer);
5463 simdutf_warn_unused result convert_utf32_to_utf16_with_errors(const char32_t * buf, size_t len, char16_t* utf16_buffer) noexcept {
5465   return convert_utf32_to_utf16be_with_errors(buf, len, utf16_buffer);
5467   return convert_utf32_to_utf16le_with_errors(buf, len, utf16_buffer);
5470 simdutf_warn_unused result convert_utf32_to_utf16le_with_errors(const char32_t * buf, size_t len, char16_t* utf16_buffer) noexcept {
5471   return get_active_implementation()->convert_utf32_to_utf16le_with_errors(buf, len, utf16_buffer);
5473 simdutf_warn_unused result convert_utf32_to_utf16be_with_errors(const char32_t * buf, size_t len, char16_t* utf16_buffer) noexcept {
5474   return get_active_implementation()->convert_utf32_to_utf16be_with_errors(buf, len, utf16_buffer);
5476 simdutf_warn_unused size_t convert_valid_utf32_to_utf16(const char32_t * buf, size_t len, char16_t* utf16_buffer) noexcept {
5478   return convert_valid_utf32_to_utf16be(buf, len, utf16_buffer);
5480   return convert_valid_utf32_to_utf16le(buf, len, utf16_buffer);
5483 simdutf_warn_unused size_t convert_valid_utf32_to_utf16le(const char32_t * buf, size_t len, char16_t* utf16_buffer) noexcept {
5484   return get_active_implementation()->convert_valid_utf32_to_utf16le(buf, len, utf16_buffer);
5486 simdutf_warn_unused size_t convert_valid_utf32_to_utf16be(const char32_t * buf, size_t len, char16_t* utf16_buffer) noexcept {
5487   return get_active_implementation()->convert_valid_utf32_to_utf16be(buf, len, utf16_buffer);
5489 simdutf_warn_unused size_t convert_utf16_to_utf32(const char16_t * buf, size_t len, char32_t* utf32_buffer) noexcept {
5491   return convert_utf16be_to_utf32(buf, len, utf32_buffer);
5493   return convert_utf16le_to_utf32(buf, len, utf32_buffer);
5496 simdutf_warn_unused size_t convert_utf16le_to_utf32(const char16_t * buf, size_t len, char32_t* utf32_buffer) noexcept {
5497   return get_active_implementation()->convert_utf16le_to_utf32(buf, len, utf32_buffer);
5499 simdutf_warn_unused size_t convert_utf16be_to_utf32(const char16_t * buf, size_t len, char32_t* utf32_buffer) noexcept {
5500   return get_active_implementation()->convert_utf16be_to_utf32(buf, len, utf32_buffer);
5502 simdutf_warn_unused result convert_utf16_to_utf32_with_errors(const char16_t * buf, size_t len, char32_t* utf32_buffer) noexcept {
5504   return convert_utf16be_to_utf32_with_errors(buf, len, utf32_buffer);
5506   return convert_utf16le_to_utf32_with_errors(buf, len, utf32_buffer);
5509 simdutf_warn_unused result convert_utf16le_to_utf32_with_errors(const char16_t * buf, size_t len, char32_t* utf32_buffer) noexcept {
5510   return get_active_implementation()->convert_utf16le_to_utf32_with_errors(buf, len, utf32_buffer);
5512 simdutf_warn_unused result convert_utf16be_to_utf32_with_errors(const char16_t * buf, size_t len, char32_t* utf32_buffer) noexcept {
5513   return get_active_implementation()->convert_utf16be_to_utf32_with_errors(buf, len, utf32_buffer);
5515 simdutf_warn_unused size_t convert_valid_utf16_to_utf32(const char16_t * buf, size_t len, char32_t* utf32_buffer) noexcept {
5517   return convert_valid_utf16be_to_utf32(buf, len, utf32_buffer);
5519   return convert_valid_utf16le_to_utf32(buf, len, utf32_buffer);
5522 simdutf_warn_unused size_t convert_valid_utf16le_to_utf32(const char16_t * buf, size_t len, char32_t* utf32_buffer) noexcept {
5523   return get_active_implementation()->convert_valid_utf16le_to_utf32(buf, len, utf32_buffer);
5525 simdutf_warn_unused size_t convert_valid_utf16be_to_utf32(const char16_t * buf, size_t len, char32_t* utf32_buffer) noexcept {
5526   return get_active_implementation()->convert_valid_utf16be_to_utf32(buf, len, utf32_buffer);
5547 simdutf_warn_unused size_t latin1_length_from_utf8(const char * buf, size_t len) noexcept {
5548   return get_active_implementation()->latin1_length_from_utf8(buf, len);
5550 simdutf_warn_unused size_t latin1_length_from_utf16(size_t len) noexcept {
5551   return get_active_implementation()->latin1_length_from_utf16(len);
5553 simdutf_warn_unused size_t latin1_length_from_utf32(size_t len) noexcept {
5554   return get_active_implementation()->latin1_length_from_utf32(len);
5556 simdutf_warn_unused size_t utf8_length_from_latin1(const char * buf, size_t len) noexcept {
5557   return get_active_implementation()->utf8_length_from_latin1(buf, len);
10594 inline simdutf_warn_unused bool validate(const char *buf, size_t len) noexcept {
10598     for (;pos + 16 <= len; pos += 16) {
10607     for (;pos < len; pos ++) {
10614 inline simdutf_warn_unused result validate_with_errors(const char *buf, size_t len) noexcept {
10618     for (;pos + 16 <= len; pos += 16) {
10625             for (;pos < len; pos ++) {
10631     for (;pos < len; pos ++) {
10653 inline simdutf_warn_unused bool validate(const char32_t *buf, size_t len) noexcept {
10656   for(;pos < len; pos++) {
10665 inline simdutf_warn_unused result validate_with_errors(const char32_t *buf, size_t len) noexcept {
10668   for(;pos < len; pos++) {
10680 inline size_t utf8_length_from_utf32(const char32_t* buf, size_t len) {
10684   for(size_t i = 0; i < len; i++) {
10694 inline size_t utf16_length_from_utf32(const char32_t* buf, size_t len) {
10698   for(size_t i = 0; i < len; i++) {
10705 inline size_t latin1_length_from_utf32(size_t len) {
10707   return len; // a utf32 codepoint will always represent 1 latin1 character
10728 inline size_t utf32_length_from_latin1(size_t len) {
10730   return len; // a utf32 unit will always represent 1 latin1 character
10733 inline size_t utf8_length_from_latin1(const char *buf, size_t len) {
10736   for(size_t i = 0; i<len; i++) {
10739   return answer + len;
10742 inline size_t utf16_length_from_latin1(size_t len) {
10743   return len;
10765 inline size_t convert_valid(const char32_t* buf, size_t len, char* utf8_output) {
10769   while (pos < len) {
10771     if (pos + 2 <= len) { // if it is safe to read 8 more bytes, check that they are ascii
10829 inline size_t convert(const char32_t* buf, size_t len, char* utf8_output) {
10833   while (pos < len) {
10835     if (pos + 2 <= len) { // if it is safe to read 8 more bytes, check that they are ascii
10878 inline result convert_with_errors(const char32_t* buf, size_t len, char* utf8_output) {
10882   while (pos < len) {
10884     if (pos + 2 <= len) { // if it is safe to read 8 more bytes, check that they are ascii
10945 inline size_t convert_valid(const char32_t* buf, size_t len, char16_t* utf16_output) {
10949   while (pos < len) {
10989 inline size_t convert(const char32_t* buf, size_t len, char16_t* utf16_output) {
10993   while (pos < len) {
11018 inline result convert_with_errors(const char32_t* buf, size_t len, char16_t* utf16_output) {
11022   while (pos < len) {
11064 inline size_t convert_valid(const char16_t* buf, size_t len, char* utf8_output) {
11068   while (pos < len) {
11070     if (pos + 4 <= len) { // if it is safe to read 8 more bytes, check that they are ascii
11105       if(pos + 1 >= len) { return 0; } // minimal bound checking
11138 inline size_t convert(const char16_t* buf, size_t len, char* utf8_output) {
11142   while (pos < len) {
11144     if (pos + 4 <= len) { // if it is safe to read 8 more bytes, check that they are ascii
11177       if(pos + 1 >= len) { return 0; }
11197 inline result convert_with_errors(const char16_t* buf, size_t len, char* utf8_output) {
11201   while (pos < len) {
11203     if (pos + 4 <= len) { // if it is safe to read 8 more bytes, check that they are ascii
11236       if(pos + 1 >= len) { return result(error_code::SURROGATE, pos); }
11273 inline size_t convert_valid(const char16_t* buf, size_t len, char32_t* utf32_output) {
11277   while (pos < len) {
11286       if(pos + 1 >= len) { return 0; } // minimal bound checking
11314 inline size_t convert(const char16_t* buf, size_t len, char32_t* utf32_output) {
11318   while (pos < len) {
11328       if(pos + 1 >= len) { return 0; } // minimal bound checking
11341 inline result convert_with_errors(const char16_t* buf, size_t len, char32_t* utf32_output) {
11345   while (pos < len) {
11355       if(pos + 1 >= len) { return result(error_code::SURROGATE, pos); } // minimal bound checking
11385 inline size_t convert_valid(const char* buf, size_t len, char16_t* utf16_output) {
11389   while (pos < len) {
11391     if (pos + 8 <= len) { // if it is safe to read 8 more bytes, check that they are ascii
11411       if(pos + 1 >= len) { break; } // minimal bound checking
11421       if(pos + 2 >= len) { break; } // minimal bound checking
11430       if(pos + 3 >= len) { break; } // minimal bound checking
11469 inline size_t convert(const char* buf, size_t len, char16_t* utf16_output) {
11473   while (pos < len) {
11475     if (pos + 16 <= len) { // if it is safe to read 16 more bytes, check that they are ascii
11499       if(pos + 1 >= len) { return 0; } // minimal bound checking
11512       if(pos + 2 >= len) { return 0; } // minimal bound checking
11531       if(pos + 3 >= len) { return 0; } // minimal bound checking
11559 inline result convert_with_errors(const char* buf, size_t len, char16_t* utf16_output) {
11563   while (pos < len) {
11565     if (pos + 16 <= len) { // if it is safe to read 16 more bytes, check that they are ascii
11588       if(pos + 1 >= len) { return result(error_code::TOO_SHORT, pos); } // minimal bound checking
11601       if(pos + 2 >= len) { return result(error_code::TOO_SHORT, pos); } // minimal bound checking
11618       if(pos + 3 >= len) { return result(error_code::TOO_SHORT, pos); } // minimal bound checking
11650  * up to len input bytes left, and we encountered some error. It is possible that
11656  * The caller is responsible to ensure that len > 0.
11662 inline result rewind_and_convert_with_errors(size_t prior_bytes, const char* buf, size_t len, char16_t* utf16_output) {
11693   result res = convert_with_errors<endian>(buf, len + extra_len, utf16_output);
11717 inline size_t convert_valid(const char* buf, size_t len, char32_t* utf32_output) {
11721   while (pos < len) {
11723     if (pos + 8 <= len) { // if it is safe to read 8 more bytes, check that they are ascii
11742       if(pos + 1 >= len) { break; } // minimal bound checking
11747       if(pos + 2 >= len) { break; } // minimal bound checking
11752       if(pos + 3 >= len) { break; } // minimal bound checking
11782 inline size_t convert(const char* buf, size_t len, char32_t* utf32_output) {
11786   while (pos < len) {
11788     if (pos + 16 <= len) { // if it is safe to read 16 more bytes, check that they are ascii
11810       if(pos + 1 >= len) { return 0; } // minimal bound checking
11819       if(pos + 2 >= len) { return 0; } // minimal bound checking
11835       if(pos + 3 >= len) { return 0; } // minimal bound checking
11854 inline result convert_with_errors(const char* buf, size_t len, char32_t* utf32_output) {
11858   while (pos < len) {
11860     if (pos + 16 <= len) { // if it is safe to read 16 more bytes, check that they are ascii
11882       if(pos + 1 >= len) { return result(error_code::TOO_SHORT, pos); } // minimal bound checking
11891       if(pos + 2 >= len) { return result(error_code::TOO_SHORT, pos); } // minimal bound checking
11905       if(pos + 3 >= len) { return result(error_code::TOO_SHORT, pos); } // minimal bound checking
11929  * up to len input bytes left, and we encountered some error. It is possible that
11935  * The caller is responsible to ensure that len > 0.
11940 inline result rewind_and_convert_with_errors(size_t prior_bytes, const char* buf, size_t len, char32_t* utf32_output) {
11970   result res = convert_with_errors(buf, len + extra_len, utf32_output);
11994 inline size_t convert(const char* buf, size_t len, char* utf8_output) {
11998   while (pos < len) {
12000     if (pos + 16 <= len) { // if it is safe to read 16 more bytes, check that they are ascii
12048 inline size_t convert(const char* buf, size_t len, char16_t* utf16_output) {
12053   while (pos < len) {
12063 inline result convert_with_errors(const char* buf, size_t len, char16_t* utf16_output) {
12068   while (pos < len) {
12094 inline size_t convert(const char *buf, size_t len, char32_t *utf32_output) {
12097   for (size_t i = 0; i < len; i++) {
12121 inline size_t convert(const char* buf, size_t len, char* latin_output) {
12126   while (pos < len) {
12128     if (pos + 16 <= len) { // if it is safe to read 16 more bytes, check that they are ascii
12152       if(pos + 1 >= len) {
12170 inline result convert_with_errors(const char* buf, size_t len, char* latin_output) {
12175   while (pos < len) {
12177     if (pos + 16 <= len) { // if it is safe to read 16 more bytes, check that they are ascii
12200       if(pos + 1 >= len) {
12234 inline result rewind_and_convert_with_errors(size_t prior_bytes, const char* buf, size_t len, char* latin1_output) {
12265   result res = convert_with_errors(buf, len + extra_len, latin1_output);
12292 inline size_t convert(const char16_t* buf, size_t len, char* latin_output) {
12295   std::vector<char> temp_output(len);
12300   while (pos < len) {
12309   std::memcpy(latin_output, temp_output.data(), len);
12315 inline result convert_with_errors(const char16_t* buf, size_t len, char* latin_output) {
12321   while (pos < len) {
12322     if (pos + 16 <= len) { // if it is safe to read 32 more bytes, check that they are Latin1
12369 inline size_t convert(const char32_t *buf, size_t len, char *latin1_output) {
12376   while (pos < len) {
12386 inline result convert_with_errors(const char32_t *buf, size_t len, char *latin1_output) {
12390   while (pos < len) {
12391     if (pos + 2 <= len) { // if it is safe to read 8 more bytes, check that they are Latin1
12427 inline size_t convert_valid(const char* buf, size_t len, char* latin_output) {
12433   while (pos < len) {
12435     if (pos + 16 <= len) { // if it is safe to read 16 more bytes, check that they are ascii
12459       if(pos + 1 >= len) { break; } // minimal bound checking
12490 inline size_t convert_valid(const char16_t* buf, size_t len, char* latin_output) {
12496   while (pos < len) {
12521 inline size_t convert_valid(const char32_t *buf, size_t len, char *latin1_output) {
12527   while (pos < len) {
12530   if (pos + 2 <= len) { // if it is safe to read 8 more bytes, check that they are Latin1
12675 // len is known to be a multiple of 2 when this is called
12676 int arm_detect_encodings(const char * buf, size_t len) {
12678     const char* end = buf + len;
12730                 const char16_t* end16 = reinterpret_cast<const char16_t*>(start) + len/2;
12792                 if (len % 4 == 0) {
12794                     const char32_t* end32 = reinterpret_cast<const char32_t*>(start) + len/4;
12852         if (static_cast<size_t>(buf - start) != len) {
12855             std::memcpy(block, buf, len - (buf - start));
12864     if (is_utf16 && scalar::utf16::validate<endianness::LITTLE>(reinterpret_cast<const char16_t*>(buf), (len - (buf - start))/2)) {
12868     if (is_utf32 && (len % 4 == 0)) {
12871         if (vmaxvq_u32(is_zero) == 0 && scalar::utf32::validate(reinterpret_cast<const char32_t*>(buf), (len - (buf - start))/4)) {
13089 arm_convert_latin1_to_utf8(const char *latin1_input, size_t len,
13092   const char *end = latin1_input + len;
13157 std::pair<const char*, char16_t*> arm_convert_latin1_to_utf16(const char* buf, size_t len, char16_t* utf16_output) {
13158     const char* end = buf + len;
13176 std::pair<const char*, char32_t*> arm_convert_latin1_to_utf32(const char* buf, size_t len, char32_t* utf32_output) {
13177     const char* end = buf + len;
13709 std::pair<const char16_t*, char*> arm_convert_utf16_to_latin1(const char16_t* buf, size_t len, char* latin1_output) {
13710   const char16_t* end = buf + len;
13730 std::pair<result, char*> arm_convert_utf16_to_latin1_with_errors(const char16_t* buf, size_t len, char* latin1_output) {
13732   const char16_t* end = buf + len;
13813 std::pair<const char16_t*, char*> arm_convert_utf16_to_utf8(const char16_t* buf, size_t len, char* utf8_out) {
13815   const char16_t* end = buf + len;
14065 std::pair<result, char*> arm_convert_utf16_to_utf8_with_errors(const char16_t* buf, size_t len, char* utf8_out) {
14068   const char16_t* end = buf + len;
14365 std::pair<const char16_t*, char32_t*> arm_convert_utf16_to_utf32(const char16_t* buf, size_t len, char32_t* utf32_out) {
14367   const char16_t* end = buf + len;
14422 std::pair<result, char32_t*> arm_convert_utf16_to_utf32_with_errors(const char16_t* buf, size_t len, char32_t* utf32_out) {
14425   const char16_t* end = buf + len;
14474 std::pair<const char32_t*, char*> arm_convert_utf32_to_latin1(const char32_t* buf, size_t len, char* latin1_output) {
14475   const char32_t* end = buf + len;
14497 std::pair<result, char*> arm_convert_utf32_to_latin1_with_errors(const char32_t* buf, size_t len, char* latin1_output) {
14499   const char32_t* end = buf + len;
14531 std::pair<const char32_t*, char*> arm_convert_utf32_to_utf8(const char32_t* buf, size_t len, char* utf8_out) {
14533   const char32_t* end = buf + len;
14765 std::pair<result, char*> arm_convert_utf32_to_utf8_with_errors(const char32_t* buf, size_t len, char* utf8_out) {
14768   const char32_t* end = buf + len;
15001 std::pair<const char32_t*, char16_t*> arm_convert_utf32_to_utf16(const char32_t* buf, size_t len, char16_t* utf16_out) {
15003   const char32_t* end = buf + len;
15060 std::pair<result, char16_t*> arm_convert_utf32_to_utf16_with_errors(const char32_t* buf, size_t len, char16_t* utf16_out) {
15063   const char32_t* end = buf + len;
15133    * There will always be a last block, with at least 1 byte, unless len == 0 (in which case this
15134    * function fills the buffer with spaces and returns 0. In particular, if len == STEP_SIZE there
15143   const size_t len;
15179 simdutf_really_inline buf_block_reader<STEP_SIZE>::buf_block_reader(const uint8_t *_buf, size_t _len) : buf{_buf}, len{_len}, lenminusstep{len < STEP_SIZE ? 0 : len - STEP_SIZE}, idx{0} {}
15196   if(len == idx) { return 0; } // memcpy(dst, null, 0) will trigger an error with some sanitizers
15198   std::memcpy(dst, buf + idx, len - idx);
15199   return len - idx;
16755 simdutf_warn_unused bool implementation::validate_utf8(const char *buf, size_t len) const noexcept {
16756   return arm64::utf8_validation::generic_validate_utf8(buf,len);
16759 simdutf_warn_unused result implementation::validate_utf8_with_errors(const char *buf, size_t len) const noexcept {
16760   return arm64::utf8_validation::generic_validate_utf8_with_errors(buf,len);
16763 simdutf_warn_unused bool implementation::validate_ascii(const char *buf, size_t len) const noexcept {
16764   return arm64::utf8_validation::generic_validate_ascii(buf,len);
16767 simdutf_warn_unused result implementation::validate_ascii_with_errors(const char *buf, size_t len) const noexcept {
16768   return arm64::utf8_validation::generic_validate_ascii_with_errors(buf,len);
16771 simdutf_warn_unused bool implementation::validate_utf16le(const char16_t *buf, size_t len) const noexcept {
16772   const char16_t* tail = arm_validate_utf16<endianness::LITTLE>(buf, len);
16774     return scalar::utf16::validate<endianness::LITTLE>(tail, len - (tail - buf));
16780 simdutf_warn_unused bool implementation::validate_utf16be(const char16_t *buf, size_t len) const noexcept {
16781   const char16_t* tail = arm_validate_utf16<endianness::BIG>(buf, len);
16783     return scalar::utf16::validate<endianness::BIG>(tail, len - (tail - buf));
16789 simdutf_warn_unused result implementation::validate_utf16le_with_errors(const char16_t *buf, size_t len) const noexcept {
16790   result res = arm_validate_utf16_with_errors<endianness::LITTLE>(buf, len);
16791   if (res.count != len) {
16792     result scalar_res = scalar::utf16::validate_with_errors<endianness::LITTLE>(buf + res.count, len - res.count);
16799 simdutf_warn_unused result implementation::validate_utf16be_with_errors(const char16_t *buf, size_t len) const noexcept {
16800   result res = arm_validate_utf16_with_errors<endianness::BIG>(buf, len);
16801   if (res.count != len) {
16802     result scalar_res = scalar::utf16::validate_with_errors<endianness::BIG>(buf + res.count, len - res.count);
16809 simdutf_warn_unused bool implementation::validate_utf32(const char32_t *buf, size_t len) const noexcept {
16810   const char32_t* tail = arm_validate_utf32le(buf, len);
16812     return scalar::utf32::validate(tail, len - (tail - buf));
16818 simdutf_warn_unused result implementation::validate_utf32_with_errors(const char32_t *buf, size_t len) const noexcept {
16819   result res = arm_validate_utf32le_with_errors(buf, len);
16820   if (res.count != len) {
16821     result scalar_res = scalar::utf32::validate_with_errors(buf + res.count, len - res.count);
16828 simdutf_warn_unused size_t implementation::convert_latin1_to_utf8(const char * buf, size_t len, char* utf8_output) const noexcept {
16829   std::pair<const char*, char*> ret = arm_convert_latin1_to_utf8(buf, len, utf8_output);
16832   if (ret.first != buf + len) {
16834       ret.first, len - (ret.first - buf), ret.second);
16840 simdutf_warn_unused size_t implementation::convert_latin1_to_utf16le(const char* buf, size_t len, char16_t* utf16_output) const noexcept {
16841   std::pair<const char*, char16_t*> ret = arm_convert_latin1_to_utf16<endianness::LITTLE>(buf, len, utf16_output);
16843   if (ret.first != buf + len) {
16845       ret.first, len - (ret.first - buf), ret.second);
16851 simdutf_warn_unused size_t implementation::convert_latin1_to_utf16be(const char* buf, size_t len, char16_t* utf16_output) const noexcept {
16852   std::pair<const char*, char16_t*> ret = arm_convert_latin1_to_utf16<endianness::BIG>(buf, len, utf16_output);
16854   if (ret.first != buf + len) {
16856       ret.first, len - (ret.first - buf), ret.second);
16862 simdutf_warn_unused size_t implementation::convert_latin1_to_utf32(const char* buf, size_t len, char32_t* utf32_output) const noexcept {
16863   std::pair<const char*, char32_t*> ret = arm_convert_latin1_to_utf32(buf, len, utf32_output);
16865   if (ret.first != buf + len) {
16867       ret.first, len - (ret.first - buf), ret.second);
16873 simdutf_warn_unused size_t implementation::convert_utf8_to_latin1(const char* buf, size_t len, char* latin1_output) const noexcept {
16875   return converter.convert(buf, len, latin1_output);
16878 simdutf_warn_unused result implementation::convert_utf8_to_latin1_with_errors(const char* buf, size_t len, char* latin1_output) const noexcept {
16880   return converter.convert_with_errors(buf, len, latin1_output);
16883 simdutf_warn_unused size_t implementation::convert_valid_utf8_to_latin1(const char* buf, size_t len, char* latin1_output) const noexcept {
16884   return arm64::utf8_to_latin1::convert_valid(buf,len,latin1_output);
16887 simdutf_warn_unused size_t implementation::convert_utf8_to_utf16le(const char* buf, size_t len, char16_t* utf16_output) const noexcept {
16889   return converter.convert<endianness::LITTLE>(buf, len, utf16_output);
16892 simdutf_warn_unused size_t implementation::convert_utf8_to_utf16be(const char* buf, size_t len, char16_t* utf16_output) const noexcept {
16894   return converter.convert<endianness::BIG>(buf, len, utf16_output);
16897 simdutf_warn_unused result implementation::convert_utf8_to_utf16le_with_errors(const char* buf, size_t len, char16_t* utf16_output) const noexcept {
16899   return converter.convert_with_errors<endianness::LITTLE>(buf, len, utf16_output);
16902 simdutf_warn_unused result implementation::convert_utf8_to_utf16be_with_errors(const char* buf, size_t len, char16_t* utf16_output) const noexcept {
16904   return converter.convert_with_errors<endianness::BIG>(buf, len, utf16_output);
16917 simdutf_warn_unused size_t implementation::convert_utf8_to_utf32(const char* buf, size_t len, char32_t* utf32_output) const noexcept {
16919   return converter.convert(buf, len, utf32_output);
16922 simdutf_warn_unused result implementation::convert_utf8_to_utf32_with_errors(const char* buf, size_t len, char32_t* utf32_output) const noexcept {
16924   return converter.convert_with_errors(buf, len, utf32_output);
16932 simdutf_warn_unused size_t implementation::convert_utf16le_to_latin1(const char16_t* buf, size_t len, char* latin1_output) const noexcept {
16933   std::pair<const char16_t*, char*> ret = arm_convert_utf16_to_latin1<endianness::LITTLE>(buf, len, latin1_output);
16937   if (ret.first != buf + len) {
16939                                         ret.first, len - (ret.first - buf), ret.second);
16946 simdutf_warn_unused size_t implementation::convert_utf16be_to_latin1(const char16_t* buf, size_t len, char* latin1_output) const noexcept {
16947   std::pair<const char16_t*, char*> ret = arm_convert_utf16_to_latin1<endianness::BIG>(buf, len, latin1_output);
16951   if (ret.first != buf + len) {
16953                                         ret.first, len - (ret.first - buf), ret.second);
16960 simdutf_warn_unused result implementation::convert_utf16le_to_latin1_with_errors(const char16_t* buf, size_t len, char* latin1_output) const noexcept {
16961   std::pair<result, char*> ret = arm_convert_utf16_to_latin1_with_errors<endianness::LITTLE>(buf, len, latin1_output);
16963   if (ret.first.count != len) { // All good so far, but not finished
16965                                         buf + ret.first.count, len - ret.first.count, ret.second);
16977 simdutf_warn_unused result implementation::convert_utf16be_to_latin1_with_errors(const char16_t* buf, size_t len, char* latin1_output) const noexcept {
16978   std::pair<result, char*> ret = arm_convert_utf16_to_latin1_with_errors<endianness::BIG>(buf, len, latin1_output);
16980   if (ret.first.count != len) { // All good so far, but not finished
16982                                         buf + ret.first.count, len - ret.first.count, ret.second);
16994 simdutf_warn_unused size_t implementation::convert_valid_utf16be_to_latin1(const char16_t* buf, size_t len, char* latin1_output) const noexcept {
16996   return convert_utf16be_to_latin1(buf, len, latin1_output);
16999 simdutf_warn_unused size_t implementation::convert_valid_utf16le_to_latin1(const char16_t* buf, size_t len, char* latin1_output) const noexcept {
17001   return convert_utf16le_to_latin1(buf, len, latin1_output);
17004 simdutf_warn_unused size_t implementation::convert_utf16le_to_utf8(const char16_t* buf, size_t len, char* utf8_output) const noexcept {
17005   std::pair<const char16_t*, char*> ret = arm_convert_utf16_to_utf8<endianness::LITTLE>(buf, len, utf8_output);
17008   if (ret.first != buf + len) {
17010                                         ret.first, len - (ret.first - buf), ret.second);
17017 simdutf_warn_unused size_t implementation::convert_utf16be_to_utf8(const char16_t* buf, size_t len, char* utf8_output) const noexcept {
17018   std::pair<const char16_t*, char*> ret = arm_convert_utf16_to_utf8<endianness::BIG>(buf, len, utf8_output);
17021   if (ret.first != buf + len) {
17023                                         ret.first, len - (ret.first - buf), ret.second);
17030 simdutf_warn_unused result implementation::convert_utf16le_to_utf8_with_errors(const char16_t* buf, size_t len, char* utf8_output) const noexcept {
17032   std::pair<result, char*> ret = arm_convert_utf16_to_utf8_with_errors<endianness::LITTLE>(buf, len, utf8_output);
17034   if (ret.first.count != len) { // All good so far, but not finished
17036                                         buf + ret.first.count, len - ret.first.count, ret.second);
17048 simdutf_warn_unused result implementation::convert_utf16be_to_utf8_with_errors(const char16_t* buf, size_t len, char* utf8_output) const noexcept {
17050   std::pair<result, char*> ret = arm_convert_utf16_to_utf8_with_errors<endianness::BIG>(buf, len, utf8_output);
17052   if (ret.first.count != len) { // All good so far, but not finished
17054                                         buf + ret.first.count, len - ret.first.count, ret.second);
17066 simdutf_warn_unused size_t implementation::convert_valid_utf16le_to_utf8(const char16_t* buf, size_t len, char* utf8_output) const noexcept {
17067   return convert_utf16le_to_utf8(buf, len, utf8_output);
17070 simdutf_warn_unused size_t implementation::convert_valid_utf16be_to_utf8(const char16_t* buf, size_t len, char* utf8_output) const noexcept {
17071   return convert_utf16be_to_utf8(buf, len, utf8_output);
17074 simdutf_warn_unused size_t implementation::convert_utf32_to_utf8(const char32_t* buf, size_t len, char* utf8_output) const noexcept {
17075   std::pair<const char32_t*, char*> ret = arm_convert_utf32_to_utf8(buf, len, utf8_output);
17078   if (ret.first != buf + len) {
17080                                         ret.first, len - (ret.first - buf), ret.second);
17087 simdutf_warn_unused result implementation::convert_utf32_to_utf8_with_errors(const char32_t* buf, size_t len, char* utf8_output) const noexcept {
17089   std::pair<result, char*> ret = arm_convert_utf32_to_utf8_with_errors(buf, len, utf8_output);
17090   if (ret.first.count != len) {
17092                                         buf + ret.first.count, len - ret.first.count, ret.second);
17104 simdutf_warn_unused size_t implementation::convert_utf16le_to_utf32(const char16_t* buf, size_t len, char32_t* utf32_output) const noexcept {
17105   std::pair<const char16_t*, char32_t*> ret = arm_convert_utf16_to_utf32<endianness::LITTLE>(buf, len, utf32_output);
17108   if (ret.first != buf + len) {
17110                                         ret.first, len - (ret.first - buf), ret.second);
17117 simdutf_warn_unused size_t implementation::convert_utf16be_to_utf32(const char16_t* buf, size_t len, char32_t* utf32_output) const noexcept {
17118   std::pair<const char16_t*, char32_t*> ret = arm_convert_utf16_to_utf32<endianness::BIG>(buf, len, utf32_output);
17121   if (ret.first != buf + len) {
17123                                         ret.first, len - (ret.first - buf), ret.second);
17130 simdutf_warn_unused result implementation::convert_utf16le_to_utf32_with_errors(const char16_t* buf, size_t len, char32_t* utf32_output) const noexcept {
17132   std::pair<result, char32_t*> ret = arm_convert_utf16_to_utf32_with_errors<endianness::LITTLE>(buf, len, utf32_output);
17134   if (ret.first.count != len) { // All good so far, but not finished
17136                                         buf + ret.first.count, len - ret.first.count, ret.second);
17148 simdutf_warn_unused result implementation::convert_utf16be_to_utf32_with_errors(const char16_t* buf, size_t len, char32_t* utf32_output) const noexcept {
17150   std::pair<result, char32_t*> ret = arm_convert_utf16_to_utf32_with_errors<endianness::BIG>(buf, len, utf32_output);
17152   if (ret.first.count != len) { // All good so far, but not finished
17154                                         buf + ret.first.count, len - ret.first.count, ret.second);
17166 simdutf_warn_unused size_t implementation::convert_utf32_to_latin1(const char32_t* buf, size_t len, char* latin1_output) const noexcept {
17167   std::pair<const char32_t*, char*> ret = arm_convert_utf32_to_latin1(buf, len, latin1_output);
17171   if (ret.first != buf + len) {
17173                                         ret.first, len - (ret.first - buf), ret.second);
17180 simdutf_warn_unused result implementation::convert_utf32_to_latin1_with_errors(const char32_t* buf, size_t len, char* latin1_output) const noexcept {
17181   std::pair<result, char*> ret = arm_convert_utf32_to_latin1_with_errors(buf, len, latin1_output);
17183   if (ret.first.count != len) { // All good so far, but not finished
17185                                         buf + ret.first.count, len - ret.first.count, ret.second);
17197 simdutf_warn_unused size_t implementation::convert_valid_utf32_to_latin1(const char32_t* buf, size_t len, char* latin1_output) const noexcept {
17198   std::pair<const char32_t*, char*> ret = arm_convert_utf32_to_latin1(buf, len, latin1_output);
17202   if (ret.first != buf + len) {
17204                                         ret.first, len - (ret.first - buf), ret.second);
17210 simdutf_warn_unused size_t implementation::convert_valid_utf32_to_utf8(const char32_t* buf, size_t len, char* utf8_output) const noexcept {
17212   return convert_utf32_to_utf8(buf, len, utf8_output);
17215 simdutf_warn_unused size_t implementation::convert_utf32_to_utf16le(const char32_t* buf, size_t len, char16_t* utf16_output) const noexcept {
17216   std::pair<const char32_t*, char16_t*> ret = arm_convert_utf32_to_utf16<endianness::LITTLE>(buf, len, utf16_output);
17219   if (ret.first != buf + len) {
17221                                         ret.first, len - (ret.first - buf), ret.second);
17228 simdutf_warn_unused size_t implementation::convert_utf32_to_utf16be(const char32_t* buf, size_t len, char16_t* utf16_output) const noexcept {
17229   std::pair<const char32_t*, char16_t*> ret = arm_convert_utf32_to_utf16<endianness::BIG>(buf, len, utf16_output);
17232   if (ret.first != buf + len) {
17234                                         ret.first, len - (ret.first - buf), ret.second);
17241 simdutf_warn_unused result implementation::convert_utf32_to_utf16le_with_errors(const char32_t* buf, size_t len, char16_t* utf16_output) const noexcept {
17243   std::pair<result, char16_t*> ret = arm_convert_utf32_to_utf16_with_errors<endianness::LITTLE>(buf, len, utf16_output);
17244   if (ret.first.count != len) {
17246                                         buf + ret.first.count, len - ret.first.count, ret.second);
17258 simdutf_warn_unused result implementation::convert_utf32_to_utf16be_with_errors(const char32_t* buf, size_t len, char16_t* utf16_output) const noexcept {
17260   std::pair<result, char16_t*> ret = arm_convert_utf32_to_utf16_with_errors<endianness::BIG>(buf, len, utf16_output);
17261   if (ret.first.count != len) {
17263                                         buf + ret.first.count, len - ret.first.count, ret.second);
17275 simdutf_warn_unused size_t implementation::convert_valid_utf32_to_utf16le(const char32_t* buf, size_t len, char16_t* utf16_output) const noexcept {
17276   return convert_utf32_to_utf16le(buf, len, utf16_output);
17279 simdutf_warn_unused size_t implementation::convert_valid_utf32_to_utf16be(const char32_t* buf, size_t len, char16_t* utf16_output) const noexcept {
17280   return convert_utf32_to_utf16be(buf, len, utf16_output);
17283 simdutf_warn_unused size_t implementation::convert_valid_utf16le_to_utf32(const char16_t* buf, size_t len, char32_t* utf32_output) const noexcept {
17284   return convert_utf16le_to_utf32(buf, len, utf32_output);
17287 simdutf_warn_unused size_t implementation::convert_valid_utf16be_to_utf32(const char16_t* buf, size_t len, char32_t* utf32_output) const noexcept {
17288   return convert_utf16be_to_utf32(buf, len, utf32_output);
17307 simdutf_warn_unused size_t implementation::latin1_length_from_utf8(const char* buf, size_t len) const noexcept {
17308   return count_utf8(buf,len);
17462 simdutf_warn_unused bool implementation::validate_utf8(const char *buf, size_t len) const noexcept {
17463   return scalar::utf8::validate(buf, len);
17466 simdutf_warn_unused result implementation::validate_utf8_with_errors(const char *buf, size_t len) const noexcept {
17467   return scalar::utf8::validate_with_errors(buf, len);
17470 simdutf_warn_unused bool implementation::validate_ascii(const char *buf, size_t len) const noexcept {
17471   return scalar::ascii::validate(buf, len);
17474 simdutf_warn_unused result implementation::validate_ascii_with_errors(const char *buf, size_t len) const noexcept {
17475   return scalar::ascii::validate_with_errors(buf, len);
17478 simdutf_warn_unused bool implementation::validate_utf16le(const char16_t *buf, size_t len) const noexcept {
17479   return scalar::utf16::validate<endianness::LITTLE>(buf, len);
17482 simdutf_warn_unused bool implementation::validate_utf16be(const char16_t *buf, size_t len) const noexcept {
17483   return scalar::utf16::validate<endianness::BIG>(buf, len);
17486 simdutf_warn_unused result implementation::validate_utf16le_with_errors(const char16_t *buf, size_t len) const noexcept {
17487   return scalar::utf16::validate_with_errors<endianness::LITTLE>(buf, len);
17490 simdutf_warn_unused result implementation::validate_utf16be_with_errors(const char16_t *buf, size_t len) const noexcept {
17491   return scalar::utf16::validate_with_errors<endianness::BIG>(buf, len);
17494 simdutf_warn_unused bool implementation::validate_utf32(const char32_t *buf, size_t len) const noexcept {
17495   return scalar::utf32::validate(buf, len);
17498 simdutf_warn_unused result implementation::validate_utf32_with_errors(const char32_t *buf, size_t len) const noexcept {
17499   return scalar::utf32::validate_with_errors(buf, len);
17502 simdutf_warn_unused size_t implementation::convert_latin1_to_utf8(const char * buf, size_t len, char* utf8_output) const noexcept {
17503   return scalar::latin1_to_utf8::convert(buf,len,utf8_output);
17506 simdutf_warn_unused size_t implementation::convert_latin1_to_utf16le(const char* buf, size_t len, char16_t* utf16_output) const noexcept {
17507   return scalar::latin1_to_utf16::convert<endianness::LITTLE>(buf, len, utf16_output);
17510 simdutf_warn_unused size_t implementation::convert_latin1_to_utf16be(const char* buf, size_t len, char16_t* utf16_output) const noexcept {
17511   return scalar::latin1_to_utf16::convert<endianness::BIG>(buf, len, utf16_output);
17514 simdutf_warn_unused size_t implementation::convert_latin1_to_utf32(const char * buf, size_t len, char32_t* utf32_output) const noexcept {
17515   return scalar::latin1_to_utf32::convert(buf,len,utf32_output);
17518 simdutf_warn_unused size_t implementation::convert_utf8_to_latin1(const char* buf, size_t len, char* latin1_output) const noexcept {
17519   return scalar::utf8_to_latin1::convert(buf, len, latin1_output);
17522 simdutf_warn_unused result implementation::convert_utf8_to_latin1_with_errors(const char* buf, size_t len, char* latin1_output) const noexcept {
17523   return scalar::utf8_to_latin1::convert_with_errors(buf, len, latin1_output);
17526 simdutf_warn_unused size_t implementation::convert_valid_utf8_to_latin1(const char* buf, size_t len, char* latin1_output) const noexcept {
17527   return scalar::utf8_to_latin1::convert_valid(buf, len, latin1_output);
17530 simdutf_warn_unused size_t implementation::convert_utf8_to_utf16le(const char* buf, size_t len, char16_t* utf16_output) const noexcept {
17531   return scalar::utf8_to_utf16::convert<endianness::LITTLE>(buf, len, utf16_output);
17534 simdutf_warn_unused size_t implementation::convert_utf8_to_utf16be(const char* buf, size_t len, char16_t* utf16_output) const noexcept {
17535   return scalar::utf8_to_utf16::convert<endianness::BIG>(buf, len, utf16_output);
17538 simdutf_warn_unused result implementation::convert_utf8_to_utf16le_with_errors(const char* buf, size_t len, char16_t* utf16_output) const noexcept {
17539   return scalar::utf8_to_utf16::convert_with_errors<endianness::LITTLE>(buf, len, utf16_output);
17542 simdutf_warn_unused result implementation::convert_utf8_to_utf16be_with_errors(const char* buf, size_t len, char16_t* utf16_output) const noexcept {
17543   return scalar::utf8_to_utf16::convert_with_errors<endianness::BIG>(buf, len, utf16_output);
17546 simdutf_warn_unused size_t implementation::convert_valid_utf8_to_utf16le(const char* buf, size_t len, char16_t* utf16_output) const noexcept {
17547   return scalar::utf8_to_utf16::convert_valid<endianness::LITTLE>(buf, len, utf16_output);
17550 simdutf_warn_unused size_t implementation::convert_valid_utf8_to_utf16be(const char* buf, size_t len, char16_t* utf16_output) const noexcept {
17551   return scalar::utf8_to_utf16::convert_valid<endianness::BIG>(buf, len, utf16_output);
17554 simdutf_warn_unused size_t implementation::convert_utf8_to_utf32(const char* buf, size_t len, char32_t* utf32_output) const noexcept {
17555   return scalar::utf8_to_utf32::convert(buf, len, utf32_output);
17558 simdutf_warn_unused result implementation::convert_utf8_to_utf32_with_errors(const char* buf, size_t len, char32_t* utf32_output) const noexcept {
17559   return scalar::utf8_to_utf32::convert_with_errors(buf, len, utf32_output);
17567 simdutf_warn_unused size_t implementation::convert_utf16le_to_latin1(const char16_t* buf, size_t len, char* latin1_output) const noexcept {
17568   return scalar::utf16_to_latin1::convert<endianness::LITTLE>(buf, len, latin1_output);
17571 simdutf_warn_unused size_t implementation::convert_utf16be_to_latin1(const char16_t* buf, size_t len, char* latin1_output) const noexcept {
17572   return scalar::utf16_to_latin1::convert<endianness::BIG>(buf, len, latin1_output);
17575 simdutf_warn_unused result implementation::convert_utf16le_to_latin1_with_errors(const char16_t* buf, size_t len, char* latin1_output) const noexcept {
17576   return scalar::utf16_to_latin1::convert_with_errors<endianness::LITTLE>(buf, len, latin1_output);
17579 simdutf_warn_unused result implementation::convert_utf16be_to_latin1_with_errors(const char16_t* buf, size_t len, char* latin1_output) const noexcept {
17580   return scalar::utf16_to_latin1::convert_with_errors<endianness::BIG>(buf, len, latin1_output);
17583 simdutf_warn_unused size_t implementation::convert_valid_utf16le_to_latin1(const char16_t* buf, size_t len, char* latin1_output) const noexcept {
17584   return scalar::utf16_to_latin1::convert_valid<endianness::LITTLE>(buf, len, latin1_output);
17587 simdutf_warn_unused size_t implementation::convert_valid_utf16be_to_latin1(const char16_t* buf, size_t len, char* latin1_output) const noexcept {
17588   return scalar::utf16_to_latin1::convert_valid<endianness::BIG>(buf, len, latin1_output);
17591 simdutf_warn_unused size_t implementation::convert_utf16le_to_utf8(const char16_t* buf, size_t len, char* utf8_output) const noexcept {
17592   return scalar::utf16_to_utf8::convert<endianness::LITTLE>(buf, len, utf8_output);
17595 simdutf_warn_unused size_t implementation::convert_utf16be_to_utf8(const char16_t* buf, size_t len, char* utf8_output) const noexcept {
17596   return scalar::utf16_to_utf8::convert<endianness::BIG>(buf, len, utf8_output);
17599 simdutf_warn_unused result implementation::convert_utf16le_to_utf8_with_errors(const char16_t* buf, size_t len, char* utf8_output) const noexcept {
17600   return scalar::utf16_to_utf8::convert_with_errors<endianness::LITTLE>(buf, len, utf8_output);
17603 simdutf_warn_unused result implementation::convert_utf16be_to_utf8_with_errors(const char16_t* buf, size_t len, char* utf8_output) const noexcept {
17604   return scalar::utf16_to_utf8::convert_with_errors<endianness::BIG>(buf, len, utf8_output);
17607 simdutf_warn_unused size_t implementation::convert_valid_utf16le_to_utf8(const char16_t* buf, size_t len, char* utf8_output) const noexcept {
17608   return scalar::utf16_to_utf8::convert_valid<endianness::LITTLE>(buf, len, utf8_output);
17611 simdutf_warn_unused size_t implementation::convert_valid_utf16be_to_utf8(const char16_t* buf, size_t len, char* utf8_output) const noexcept {
17612   return scalar::utf16_to_utf8::convert_valid<endianness::BIG>(buf, len, utf8_output);
17615 simdutf_warn_unused size_t implementation::convert_utf32_to_latin1(const char32_t* buf, size_t len, char* latin1_output) const noexcept {
17616   return scalar::utf32_to_latin1::convert(buf, len, latin1_output);
17619 simdutf_warn_unused result implementation::convert_utf32_to_latin1_with_errors(const char32_t* buf, size_t len, char* latin1_output) const noexcept {
17620   return scalar::utf32_to_latin1::convert_with_errors(buf, len, latin1_output);
17623 simdutf_warn_unused size_t implementation::convert_valid_utf32_to_latin1(const char32_t* buf, size_t len, char* latin1_output) const noexcept {
17624   return scalar::utf32_to_latin1::convert_valid(buf, len, latin1_output);
17627 simdutf_warn_unused size_t implementation::convert_utf32_to_utf8(const char32_t* buf, size_t len, char* utf8_output) const noexcept {
17628   return scalar::utf32_to_utf8::convert(buf, len, utf8_output);
17631 simdutf_warn_unused result implementation::convert_utf32_to_utf8_with_errors(const char32_t* buf, size_t len, char* utf8_output) const noexcept {
17632   return scalar::utf32_to_utf8::convert_with_errors(buf, len, utf8_output);
17635 simdutf_warn_unused size_t implementation::convert_valid_utf32_to_utf8(const char32_t* buf, size_t len, char* utf8_output) const noexcept {
17636   return scalar::utf32_to_utf8::convert_valid(buf, len, utf8_output);
17639 simdutf_warn_unused size_t implementation::convert_utf32_to_utf16le(const char32_t* buf, size_t len, char16_t* utf16_output) const noexcept {
17640   return scalar::utf32_to_utf16::convert<endianness::LITTLE>(buf, len, utf16_output);
17643 simdutf_warn_unused size_t implementation::convert_utf32_to_utf16be(const char32_t* buf, size_t len, char16_t* utf16_output) const noexcept {
17644   return scalar::utf32_to_utf16::convert<endianness::BIG>(buf, len, utf16_output);
17647 simdutf_warn_unused result implementation::convert_utf32_to_utf16le_with_errors(const char32_t* buf, size_t len, char16_t* utf16_output) const noexcept {
17648   return scalar::utf32_to_utf16::convert_with_errors<endianness::LITTLE>(buf, len, utf16_output);
17651 simdutf_warn_unused result implementation::convert_utf32_to_utf16be_with_errors(const char32_t* buf, size_t len, char16_t* utf16_output) const noexcept {
17652   return scalar::utf32_to_utf16::convert_with_errors<endianness::BIG>(buf, len, utf16_output);
17655 simdutf_warn_unused size_t implementation::convert_valid_utf32_to_utf16le(const char32_t* buf, size_t len, char16_t* utf16_output) const noexcept {
17656   return scalar::utf32_to_utf16::convert_valid<endianness::LITTLE>(buf, len, utf16_output);
17659 simdutf_warn_unused size_t implementation::convert_valid_utf32_to_utf16be(const char32_t* buf, size_t len, char16_t* utf16_output) const noexcept {
17660   return scalar::utf32_to_utf16::convert_valid<endianness::BIG>(buf, len, utf16_output);
17663 simdutf_warn_unused size_t implementation::convert_utf16le_to_utf32(const char16_t* buf, size_t len, char32_t* utf32_output) const noexcept {
17664   return scalar::utf16_to_utf32::convert<endianness::LITTLE>(buf, len, utf32_output);
17667 simdutf_warn_unused size_t implementation::convert_utf16be_to_utf32(const char16_t* buf, size_t len, char32_t* utf32_output) const noexcept {
17668   return scalar::utf16_to_utf32::convert<endianness::BIG>(buf, len, utf32_output);
17671 simdutf_warn_unused result implementation::convert_utf16le_to_utf32_with_errors(const char16_t* buf, size_t len, char32_t* utf32_output) const noexcept {
17672   return scalar::utf16_to_utf32::convert_with_errors<endianness::LITTLE>(buf, len, utf32_output);
17675 simdutf_warn_unused result implementation::convert_utf16be_to_utf32_with_errors(const char16_t* buf, size_t len, char32_t* utf32_output) const noexcept {
17676   return scalar::utf16_to_utf32::convert_with_errors<endianness::BIG>(buf, len, utf32_output);
17679 simdutf_warn_unused size_t implementation::convert_valid_utf16le_to_utf32(const char16_t* buf, size_t len, char32_t* utf32_output) const noexcept {
17680   return scalar::utf16_to_utf32::convert_valid<endianness::LITTLE>(buf, len, utf32_output);
17683 simdutf_warn_unused size_t implementation::convert_valid_utf16be_to_utf32(const char16_t* buf, size_t len, char32_t* utf32_output) const noexcept {
17684   return scalar::utf16_to_utf32::convert_valid<endianness::BIG>(buf, len, utf32_output);
17703 simdutf_warn_unused size_t implementation::latin1_length_from_utf8(const char* buf, size_t len) const noexcept {
17704   return scalar::utf8::count_code_points(buf,len);
18602     - len           - string length
18610 std::pair<const char*, OUTPUT*> valid_utf8_to_fixed_length(const char* str, size_t len, OUTPUT* dwords) {
18627     const char* end = ptr + len;
18862  * Attempts to convert up to len 1-byte code units from in (in UTF-8 format) to
18869 utf8_to_utf16_result fast_avx512_convert_utf8_to_utf16(const char *in, size_t len, char16_t *out) {
18870   const char *const final_in = in + len;
18884 simdutf::result fast_avx512_convert_utf8_to_utf16_with_errors(const char *in, size_t len, char16_t *out) {
18887   const char *const final_in = in + len;
18909 std::pair<const char*, OUTPUT*> validating_utf8_to_fixed_length(const char* str, size_t len, OUTPUT* dwords) {
18916     const char* end = ptr + len;
19032 std::tuple<const char*, OUTPUT*, bool> validating_utf8_to_fixed_length_with_constant_checks(const char* str, size_t len, OUTPUT* dwords) {
19039     const char* end = ptr + len;
19165 simdutf_really_inline size_t process_block_from_utf8_to_latin1(const char *buf, size_t len,
19171       is_remaining ? _bzhi_u64(~0ULL, (unsigned int)len) : ~0ULL;
19179     return len;
19224 size_t utf8_to_latin1_avx512(const char *buf, size_t len, char *latin_output) {
19232   while (pos + 64 <= len) {
19242   if (pos < len) {
19243     size_t remaining = len - pos;
19262 simdutf_really_inline size_t process_valid_block_from_utf8_to_latin1(const char *buf, size_t len,
19268       is_remaining ? _bzhi_u64(~0ULL, (unsigned int)len) : ~0ULL;
19276     return len;
19299 size_t valid_utf8_to_latin1_avx512(const char *buf, size_t len,
19308   while (pos + 64 <= len) {
19315   if (pos < len) {
19316     size_t remaining = len - pos;
19329 size_t icelake_convert_utf16_to_latin1(const char16_t *buf, size_t len,
19331   const char16_t *end = buf + len;
19368   return len;
19373 icelake_convert_utf16_to_latin1_with_errors(const char16_t *buf, size_t len,
19375   const char16_t *end = buf + len;
19428   return std::make_pair(result(error_code::SUCCESS, len), latin1_output);
19638 std::tuple<const char16_t*, char32_t*, bool> convert_utf16_to_utf32(const char16_t* buf, size_t len, char32_t* utf32_output) {
19639   const char16_t* end = buf + len;
19743 size_t icelake_convert_utf32_to_latin1(const char32_t *buf, size_t len,
19745   const char32_t *end = buf + len;
19771   return len;
19775 icelake_convert_utf32_to_latin1_with_errors(const char32_t *buf, size_t len,
19777   const char32_t *end = buf + len;
19812   return std::make_pair(result(error_code::SUCCESS, len), latin1_output);
19819 std::pair<const char32_t*, char*> avx512_convert_utf32_to_utf8(const char32_t* buf, size_t len, char* utf8_output) {
19820   const char32_t* end = buf + len;
20059 std::pair<result, char*> avx512_convert_utf32_to_utf8_with_errors(const char32_t* buf, size_t len, char* utf8_output) {
20060   const char32_t* end = buf + len;
20305 std::pair<const char32_t*, char16_t*> avx512_convert_utf32_to_utf16(const char32_t* buf, size_t len, char16_t* utf16_output) {
20306   const char32_t* end = buf + len;
20371 std::pair<result, char16_t*> avx512_convert_utf32_to_utf16_with_errors(const char32_t* buf, size_t len, char16_t* utf16_output) {
20373   const char32_t* end = buf + len;
20437 bool validate_ascii(const char* buf, size_t len) {
20438   const char* end = buf + len;
20455 const char32_t* validate_utf32(const char32_t* buf, size_t len) {
20456     const char32_t* end = len >= 16 ? buf + len - 16 : nullptr;
20567 size_t latin1_to_utf8_avx512_start(const char *buf, size_t len, char *utf8_output) {
20571   for (; pos + 128 <= len; pos += 64) {
20576   if (pos + 64 <= len) {
20582   if (pos < len) {
20583     __mmask64 load_mask = _bzhi_u64(~0ULL, (unsigned int)(len - pos));
20585     utf8_output += latin1_to_utf8_avx512_vec(input, len - pos, utf8_output, 1);
20593 size_t icelake_convert_latin1_to_utf16(const char *latin1_input, size_t len,
20595   size_t rounded_len = len & ~0x1F; // Round down to nearest multiple of 32
20612   if (rounded_len != len) {
20613     uint32_t mask = uint32_t(1 << (len - rounded_len)) - 1;
20625   return len;
20629 std::pair<const char*, char32_t*> avx512_convert_latin1_to_utf32(const char* buf, size_t len, char32_t* utf32_output) {
20630     size_t rounded_len = len & ~0xF;  // Round down to nearest multiple of 16
20789 simdutf_warn_unused bool implementation::validate_utf8(const char *buf, size_t len) const noexcept {
20792     const char* end = ptr + len;
20805 simdutf_warn_unused result implementation::validate_utf8_with_errors(const char *buf, size_t len) const noexcept {
20808     const char* end = ptr + len;
20815         result res = scalar::utf8::rewind_and_validate_with_errors(reinterpret_cast<const char*>(buf), reinterpret_cast<const char*>(buf + count), len - count);
20826         result res = scalar::utf8::rewind_and_validate_with_errors(reinterpret_cast<const char*>(buf), reinterpret_cast<const char*>(buf + count), len - count);
20830         return result(error_code::SUCCESS, len);
20835 simdutf_warn_unused bool implementation::validate_ascii(const char *buf, size_t len) const noexcept {
20836   return icelake::validate_ascii(buf, len);
20839 simdutf_warn_unused result implementation::validate_ascii_with_errors(const char *buf, size_t len) const noexcept {
20841   const char* end = buf + len;
20857   return result(error_code::SUCCESS, len);
20860 simdutf_warn_unused bool implementation::validate_utf16le(const char16_t *buf, size_t len) const noexcept {
20861     const char16_t *end = buf + len;
20900 simdutf_warn_unused bool implementation::validate_utf16be(const char16_t *buf, size_t len) const noexcept {
20901    const char16_t *end = buf + len;
20949 simdutf_warn_unused result implementation::validate_utf16le_with_errors(const char16_t *buf, size_t len) const noexcept {
20951     const char16_t *end = buf + len;
20990     return result(error_code::SUCCESS, len);
20993 simdutf_warn_unused result implementation::validate_utf16be_with_errors(const char16_t *buf, size_t len) const noexcept {
20995     const char16_t *end = buf + len;
21044     return result(error_code::SUCCESS, len);
21047 simdutf_warn_unused bool implementation::validate_utf32(const char32_t *buf, size_t len) const noexcept {
21048   const char32_t * tail = icelake::validate_utf32(buf, len);
21050     return scalar::utf32::validate(tail, len - (tail - buf));
21056 simdutf_warn_unused result implementation::validate_utf32_with_errors(const char32_t *buf, size_t len) const noexcept {
21058     const char32_t* end = len >= 16 ? buf + len - 16 : nullptr;
21077     if(buf < buf_orig + len) {
21078       __m512i utf32 = _mm512_maskz_loadu_epi32(__mmask16((1<<(buf_orig + len - buf))-1),(const __m512i*)buf);
21093     return result(error_code::SUCCESS, len);
21096 simdutf_warn_unused size_t implementation::convert_latin1_to_utf8(const char * buf, size_t len, char* utf8_output) const noexcept {
21097   return icelake::latin1_to_utf8_avx512_start(buf, len, utf8_output);
21100 simdutf_warn_unused size_t implementation::convert_latin1_to_utf16le(const char* buf, size_t len, char16_t* utf16_output) const noexcept {
21101   return icelake_convert_latin1_to_utf16<endianness::LITTLE>(buf, len, utf16_output);
21104 simdutf_warn_unused size_t implementation::convert_latin1_to_utf16be(const char* buf, size_t len, char16_t* utf16_output) const noexcept {
21105   return icelake_convert_latin1_to_utf16<endianness::BIG>(buf, len, utf16_output);
21108 simdutf_warn_unused size_t implementation::convert_latin1_to_utf32(const char* buf, size_t len, char32_t* utf32_output) const noexcept {
21109     std::pair<const char*, char32_t*> ret = avx512_convert_latin1_to_utf32(buf, len, utf32_output);
21112     if (ret.first != buf + len) {
21114                                               ret.first, len - (ret.first - buf), ret.second);
21121 simdutf_warn_unused size_t implementation::convert_utf8_to_latin1(const char* buf, size_t len, char* latin1_output) const noexcept {
21122   return icelake::utf8_to_latin1_avx512(buf, len, latin1_output);
21126 simdutf_warn_unused result implementation::convert_utf8_to_latin1_with_errors(const char* buf, size_t len, char* latin1_output) const noexcept {
21131   inlen = icelake::utf8_to_latin1_avx512(buf, len, latin1_output);
21134   if(inlen == len) {
21135     return {simdutf::SUCCESS, len};
21142   result res = scalar::utf8_to_latin1::convert_with_errors(buf + inlen, len - inlen, latin1_output + inlen);
21149 simdutf_warn_unused size_t implementation::convert_valid_utf8_to_latin1(const char* buf, size_t len, char* latin1_output) const noexcept {
21150   return icelake::valid_utf8_to_latin1_avx512(buf, len, latin1_output);
21153 simdutf_warn_unused size_t implementation::convert_utf8_to_utf16le(const char* buf, size_t len, char16_t* utf16_output) const noexcept {
21154   utf8_to_utf16_result ret = fast_avx512_convert_utf8_to_utf16<endianness::LITTLE>(buf, len, utf16_output);
21161 simdutf_warn_unused size_t implementation::convert_utf8_to_utf16be(const char* buf, size_t len, char16_t* utf16_output) const noexcept {
21162   utf8_to_utf16_result ret = fast_avx512_convert_utf8_to_utf16<endianness::BIG>(buf, len, utf16_output);
21169 simdutf_warn_unused result implementation::convert_utf8_to_utf16le_with_errors(const char* buf, size_t len, char16_t* utf16_output) const noexcept {
21170    return fast_avx512_convert_utf8_to_utf16_with_errors<endianness::LITTLE>(buf, len, utf16_output);
21173 simdutf_warn_unused result implementation::convert_utf8_to_utf16be_with_errors(const char* buf, size_t len, char16_t* utf16_output) const noexcept {
21174    return fast_avx512_convert_utf8_to_utf16_with_errors<endianness::BIG>(buf, len, utf16_output);
21177 simdutf_warn_unused size_t implementation::convert_valid_utf8_to_utf16le(const char* buf, size_t len, char16_t* utf16_output) const noexcept {
21178   utf8_to_utf16_result ret = icelake::valid_utf8_to_fixed_length<endianness::LITTLE, char16_t>(buf, len, utf16_output);
21180   const char* end = buf + len;
21196                                         ret.first, len - (ret.first - buf), ret.second);
21204 simdutf_warn_unused size_t implementation::convert_valid_utf8_to_utf16be(const char* buf, size_t len, char16_t* utf16_output) const noexcept {
21205   utf8_to_utf16_result ret = icelake::valid_utf8_to_fixed_length<endianness::BIG, char16_t>(buf, len, utf16_output);
21207   const char* end = buf + len;
21223                                         ret.first, len - (ret.first - buf), ret.second);
21232 simdutf_warn_unused size_t implementation::convert_utf8_to_utf32(const char* buf, size_t len, char32_t* utf32_out) const noexcept {
21234   utf8_to_utf32_result ret = icelake::validating_utf8_to_fixed_length<endianness::LITTLE, uint32_t>(buf, len, utf32_output);
21239   const char* end = buf + len;
21255                                         ret.first, len - (ret.first - buf), utf32_out + saved_bytes);
21263 simdutf_warn_unused result implementation::convert_utf8_to_utf32_with_errors(const char* buf, size_t len, char32_t* utf32) const noexcept {
21265   auto ret = icelake::validating_utf8_to_fixed_length_with_constant_checks<endianness::LITTLE, uint32_t>(buf, len, utf32_output);
21269     // with the ability to go back up to new_buf - buf bytes, and read len - (new_buf - buf) bytes forward.
21270     result res = scalar::utf8_to_utf32::rewind_and_convert_with_errors(new_buf - buf, new_buf, len - (new_buf - buf), reinterpret_cast<char32_t *>(std::get<1>(ret)));
21275   const char* end = buf + len;
21291                                         std::get<0>(ret), len - (std::get<0>(ret) - buf), reinterpret_cast<char32_t *>(utf32_output) + saved_bytes);
21304 simdutf_warn_unused size_t implementation::convert_valid_utf8_to_utf32(const char* buf, size_t len, char32_t* utf32_out) const noexcept {
21306   utf8_to_utf32_result ret = icelake::valid_utf8_to_fixed_length<endianness::LITTLE, uint32_t>(buf, len, utf32_output);
21308   const char* end = buf + len;
21324                                         ret.first, len - (ret.first - buf), utf32_out + saved_bytes);
21333 simdutf_warn_unused size_t implementation::convert_utf16le_to_latin1(const char16_t* buf, size_t len, char* latin1_output) const noexcept {
21334   return icelake_convert_utf16_to_latin1<endianness::LITTLE>(buf,len,latin1_output);
21337 simdutf_warn_unused size_t implementation::convert_utf16be_to_latin1(const char16_t* buf, size_t len, char* latin1_output) const noexcept {
21338   return icelake_convert_utf16_to_latin1<endianness::BIG>(buf,len,latin1_output);
21341 simdutf_warn_unused result implementation::convert_utf16le_to_latin1_with_errors(const char16_t* buf, size_t len, char* latin1_output) const noexcept {
21342   return icelake_convert_utf16_to_latin1_with_errors<endianness::LITTLE>(buf,len,latin1_output).first;
21345 simdutf_warn_unused result implementation::convert_utf16be_to_latin1_with_errors(const char16_t* buf, size_t len, char* latin1_output) const noexcept {
21346   return icelake_convert_utf16_to_latin1_with_errors<endianness::BIG>(buf,len,latin1_output).first;
21349 simdutf_warn_unused size_t implementation::convert_valid_utf16be_to_latin1(const char16_t* buf, size_t len, char* latin1_output) const noexcept {
21351   return convert_utf16be_to_latin1(buf, len, latin1_output);
21354 simdutf_warn_unused size_t implementation::convert_valid_utf16le_to_latin1(const char16_t* buf, size_t len, char* latin1_output) const noexcept {
21356   return convert_utf16le_to_latin1(buf, len, latin1_output);
21359 simdutf_warn_unused size_t implementation::convert_utf16le_to_utf8(const char16_t* buf, size_t len, char* utf8_output) const noexcept {
21361   size_t inlen = utf16_to_utf8_avx512i<endianness::LITTLE>(buf, len, (unsigned char*)utf8_output, &outlen);
21362   if(inlen != len) { return 0; }
21366 simdutf_warn_unused size_t implementation::convert_utf16be_to_utf8(const char16_t* buf, size_t len, char* utf8_output) const noexcept {
21368   size_t inlen = utf16_to_utf8_avx512i<endianness::BIG>(buf, len, (unsigned char*)utf8_output, &outlen);
21369   if(inlen != len) { return 0; }
21373 simdutf_warn_unused result implementation::convert_utf16le_to_utf8_with_errors(const char16_t* buf, size_t len, char* utf8_output) const noexcept {
21375   size_t inlen = utf16_to_utf8_avx512i<endianness::LITTLE>(buf, len, (unsigned char*)utf8_output, &outlen);
21376   if(inlen != len) {
21377     result res = scalar::utf16_to_utf8::convert_with_errors<endianness::LITTLE>(buf + inlen, len - outlen, utf8_output + outlen);
21384 simdutf_warn_unused result implementation::convert_utf16be_to_utf8_with_errors(const char16_t* buf, size_t len, char* utf8_output) const noexcept {
21386   size_t inlen = utf16_to_utf8_avx512i<endianness::BIG>(buf, len, (unsigned char*)utf8_output, &outlen);
21387   if(inlen != len) {
21388     result res = scalar::utf16_to_utf8::convert_with_errors<endianness::BIG>(buf + inlen, len - outlen, utf8_output + outlen);
21395 simdutf_warn_unused size_t implementation::convert_valid_utf16le_to_utf8(const char16_t* buf, size_t len, char* utf8_output) const noexcept {
21396   return convert_utf16le_to_utf8(buf, len, utf8_output);
21399 simdutf_warn_unused size_t implementation::convert_valid_utf16be_to_utf8(const char16_t* buf, size_t len, char* utf8_output) const noexcept {
21400   return convert_utf16be_to_utf8(buf, len, utf8_output);
21403 simdutf_warn_unused size_t implementation::convert_utf32_to_latin1(const char32_t* buf, size_t len, char* latin1_output) const noexcept {
21404   return icelake_convert_utf32_to_latin1(buf,len,latin1_output);
21407 simdutf_warn_unused result implementation::convert_utf32_to_latin1_with_errors(const char32_t* buf, size_t len, char* latin1_output) const noexcept {
21408   return icelake_convert_utf32_to_latin1_with_errors(buf,len,latin1_output).first;
21411 simdutf_warn_unused size_t implementation::convert_valid_utf32_to_latin1(const char32_t* buf, size_t len, char* latin1_output) const noexcept {
21412   return icelake_convert_utf32_to_latin1(buf,len,latin1_output);
21416 simdutf_warn_unused size_t implementation::convert_utf32_to_utf8(const char32_t* buf, size_t len, char* utf8_output) const noexcept {
21417   std::pair<const char32_t*, char*> ret = avx512_convert_utf32_to_utf8(buf, len, utf8_output);
21420   if (ret.first != buf + len) {
21422                                         ret.first, len - (ret.first - buf), ret.second);
21429 simdutf_warn_unused result implementation::convert_utf32_to_utf8_with_errors(const char32_t* buf, size_t len, char* utf8_output) const noexcept {
21431   std::pair<result, char*> ret = icelake::avx512_convert_utf32_to_utf8_with_errors(buf, len, utf8_output);
21432   if (ret.first.count != len) {
21434                                         buf + ret.first.count, len - ret.first.count, ret.second);
21446 simdutf_warn_unused size_t implementation::convert_valid_utf32_to_utf8(const char32_t* buf, size_t len, char* utf8_output) const noexcept {
21447   return convert_utf32_to_utf8(buf, len, utf8_output);
21450 simdutf_warn_unused size_t implementation::convert_utf32_to_utf16le(const char32_t* buf, size_t len, char16_t* utf16_output) const noexcept {
21451   std::pair<const char32_t*, char16_t*> ret = avx512_convert_utf32_to_utf16<endianness::LITTLE>(buf, len, utf16_output);
21454   if (ret.first != buf + len) {
21456                                         ret.first, len - (ret.first - buf), ret.second);
21463 simdutf_warn_unused size_t implementation::convert_utf32_to_utf16be(const char32_t* buf, size_t len, char16_t* utf16_output) const noexcept {
21464   std::pair<const char32_t*, char16_t*> ret = avx512_convert_utf32_to_utf16<endianness::BIG>(buf, len, utf16_output);
21467   if (ret.first != buf + len) {
21469                                         ret.first, len - (ret.first - buf), ret.second);
21476 simdutf_warn_unused result implementation::convert_utf32_to_utf16le_with_errors(const char32_t* buf, size_t len, char16_t* utf16_output) const noexcept {
21478   std::pair<result, char16_t*> ret = avx512_convert_utf32_to_utf16_with_errors<endianness::LITTLE>(buf, len, utf16_output);
21479   if (ret.first.count != len) {
21481                                         buf + ret.first.count, len - ret.first.count, ret.second);
21493 simdutf_warn_unused result implementation::convert_utf32_to_utf16be_with_errors(const char32_t* buf, size_t len, char16_t* utf16_output) const noexcept {
21495   std::pair<result, char16_t*> ret = avx512_convert_utf32_to_utf16_with_errors<endianness::BIG>(buf, len, utf16_output);
21496   if (ret.first.count != len) {
21498                                         buf + ret.first.count, len - ret.first.count, ret.second);
21510 simdutf_warn_unused size_t implementation::convert_valid_utf32_to_utf16le(const char32_t* buf, size_t len, char16_t* utf16_output) const noexcept {
21511   return convert_utf32_to_utf16le(buf, len, utf16_output);
21514 simdutf_warn_unused size_t implementation::convert_valid_utf32_to_utf16be(const char32_t* buf, size_t len, char16_t* utf16_output) const noexcept {
21515   return convert_utf32_to_utf16be(buf, len, utf16_output);
21518 simdutf_warn_unused size_t implementation::convert_utf16le_to_utf32(const char16_t* buf, size_t len, char32_t* utf32_output) const noexcept {
21519   std::tuple<const char16_t*, char32_t*, bool> ret = icelake::convert_utf16_to_utf32<endianness::LITTLE>(buf, len, utf32_output);
21522   if (std::get<0>(ret) != buf + len) {
21524                                         std::get<0>(ret), len - (std::get<0>(ret) - buf), std::get<1>(ret));
21531 simdutf_warn_unused size_t implementation::convert_utf16be_to_utf32(const char16_t* buf, size_t len, char32_t* utf32_output) const noexcept {
21532   std::tuple<const char16_t*, char32_t*, bool> ret = icelake::convert_utf16_to_utf32<endianness::BIG>(buf, len, utf32_output);
21535   if (std::get<0>(ret) != buf + len) {
21537                                         std::get<0>(ret), len - (std::get<0>(ret) - buf), std::get<1>(ret));
21544 simdutf_warn_unused result implementation::convert_utf16le_to_utf32_with_errors(const char16_t* buf, size_t len, char32_t* utf32_output) const noexcept {
21545   std::tuple<const char16_t*, char32_t*, bool> ret = icelake::convert_utf16_to_utf32<endianness::LITTLE>(buf, len, utf32_output);
21548                                         std::get<0>(ret), len - (std::get<0>(ret) - buf), std::get<1>(ret));
21553   if (std::get<0>(ret) != buf + len) {
21555                                         std::get<0>(ret), len - (std::get<0>(ret) - buf), std::get<1>(ret));
21567 simdutf_warn_unused result implementation::convert_utf16be_to_utf32_with_errors(const char16_t* buf, size_t len, char32_t* utf32_output) const noexcept {
21568   std::tuple<const char16_t*, char32_t*, bool> ret = icelake::convert_utf16_to_utf32<endianness::BIG>(buf, len, utf32_output);
21571                                         std::get<0>(ret), len - (std::get<0>(ret) - buf), std::get<1>(ret));
21576   if (std::get<0>(ret) != buf + len) {
21578                                         std::get<0>(ret), len - (std::get<0>(ret) - buf), std::get<1>(ret));
21590 simdutf_warn_unused size_t implementation::convert_valid_utf16le_to_utf32(const char16_t* buf, size_t len, char32_t* utf32_output) const noexcept {
21591   std::tuple<const char16_t*, char32_t*, bool> ret = icelake::convert_utf16_to_utf32<endianness::LITTLE>(buf, len, utf32_output);
21594   if (std::get<0>(ret) != buf + len) {
21596                                         std::get<0>(ret), len - (std::get<0>(ret) - buf), std::get<1>(ret));
21603 simdutf_warn_unused size_t implementation::convert_valid_utf16be_to_utf32(const char16_t* buf, size_t len, char32_t* utf32_output) const noexcept {
21604   std::tuple<const char16_t*, char32_t*, bool> ret = icelake::convert_utf16_to_utf32<endianness::BIG>(buf, len, utf32_output);
21607   if (std::get<0>(ret) != buf + len) {
21609                                         std::get<0>(ret), len - (std::get<0>(ret) - buf), std::get<1>(ret));
21750 simdutf_warn_unused size_t implementation::latin1_length_from_utf8(const char* buf, size_t len) const noexcept {
21751   return count_utf8(buf,len);
22039 // len is known to be a multiple of 2 when this is called
22040 int avx2_detect_encodings(const char * buf, size_t len) {
22042     const char* end = buf + len;
22086                 const char16_t* end16 = reinterpret_cast<const char16_t*>(start) + len/2;
22149                 if (len % 4 == 0) {
22151                     const char32_t* end32 = reinterpret_cast<const char32_t*>(start) + len/4;
22198         if (static_cast<size_t>(buf - start) != len) {
22201             std::memcpy(block, buf, len - (buf - start));
22210     if (is_utf16 && scalar::utf16::validate<endianness::LITTLE>(reinterpret_cast<const char16_t*>(buf), (len - (buf - start))/2)) {
22214     if (is_utf32 && (len % 4 == 0)) {
22217         if (_mm256_testz_si256(is_zero, is_zero) == 1 && scalar::utf32::validate(reinterpret_cast<const char32_t*>(buf), (len - (buf - start))/4)) {
22492 std::pair<const char *, char *> avx2_convert_latin1_to_utf8(const char *latin1_input, size_t len,
22494   const char *end = latin1_input + len;
22575 std::pair<const char*, char16_t*> avx2_convert_latin1_to_utf16(const char* latin1_input, size_t len, char16_t* utf16_output) {
22576     size_t rounded_len = len & ~0xF; // Round down to nearest multiple of 32
22610 std::pair<const char*, char32_t*> avx2_convert_latin1_to_utf32(const char* buf, size_t len, char32_t* utf32_output) {
22611     size_t rounded_len = ((len | 7) ^ 7);  // Round down to nearest multiple of 8
22943 avx2_convert_utf16_to_latin1(const char16_t *buf, size_t len,
22945   const char16_t *end = buf + len;
22980 avx2_convert_utf16_to_latin1_with_errors(const char16_t *buf, size_t len,
22983   const char16_t *end = buf + len;
23083 std::pair<const char16_t*, char*> avx2_convert_utf16_to_utf8(const char16_t* buf, size_t len, char* utf8_output) {
23084   const char16_t* end = buf + len;
23324 std::pair<result, char*> avx2_convert_utf16_to_utf8_with_errors(const char16_t* buf, size_t len, char* utf8_output) {
23326   const char16_t* end = buf + len;
23615 std::pair<const char16_t*, char32_t*> avx2_convert_utf16_to_utf32(const char16_t* buf, size_t len, char32_t* utf32_output) {
23616   const char16_t* end = buf + len;
23682 std::pair<result, char32_t*> avx2_convert_utf16_to_utf32_with_errors(const char16_t* buf, size_t len, char32_t* utf32_output) {
23684   const char16_t* end = buf + len;
23745 avx2_convert_utf32_to_latin1(const char32_t *buf, size_t len,
23748   len & ~0x1F; // Round down to nearest multiple of 32
23787 avx2_convert_utf32_to_latin1_with_errors(const char32_t *buf, size_t len,
23790         len & ~0x1F; // Round down to nearest multiple of 32
23838 std::pair<const char32_t*, char*> avx2_convert_utf32_to_utf8(const char32_t* buf, size_t len, char* utf8_output) {
23839   const char32_t* end = buf + len;
24078 std::pair<result, char*> avx2_convert_utf32_to_utf8_with_errors(const char32_t* buf, size_t len, char* utf8_output) {
24079   const char32_t* end = buf + len;
24321 std::pair<const char32_t*, char16_t*> avx2_convert_utf32_to_utf16(const char32_t* buf, size_t len, char16_t* utf16_output) {
24322   const char32_t* end = buf + len;
24387 std::pair<result, char16_t*> avx2_convert_utf32_to_utf16_with_errors(const char32_t* buf, size_t len, char16_t* utf16_output) {
24389   const char32_t* end = buf + len;
24544    * There will always be a last block, with at least 1 byte, unless len == 0 (in which case this
24545    * function fills the buffer with spaces and returns 0. In particular, if len == STEP_SIZE there
24554   const size_t len;
24590 simdutf_really_inline buf_block_reader<STEP_SIZE>::buf_block_reader(const uint8_t *_buf, size_t _len) : buf{_buf}, len{_len}, lenminusstep{len < STEP_SIZE ? 0 : len - STEP_SIZE}, idx{0} {}
24607   if(len == idx) { return 0; } // memcpy(dst, null, 0) will trigger an error with some sanitizers
24609   std::memcpy(dst, buf + idx, len - idx);
24610   return len - idx;
26163 simdutf_warn_unused bool implementation::validate_utf8(const char *buf, size_t len) const noexcept {
26164   return haswell::utf8_validation::generic_validate_utf8(buf,len);
26167 simdutf_warn_unused result implementation::validate_utf8_with_errors(const char *buf, size_t len) const noexcept {
26168   return haswell::utf8_validation::generic_validate_utf8_with_errors(buf,len);
26171 simdutf_warn_unused bool implementation::validate_ascii(const char *buf, size_t len) const noexcept {
26172   return haswell::utf8_validation::generic_validate_ascii(buf,len);
26175 simdutf_warn_unused result implementation::validate_ascii_with_errors(const char *buf, size_t len) const noexcept {
26176   return haswell::utf8_validation::generic_validate_ascii_with_errors(buf,len);
26179 simdutf_warn_unused bool implementation::validate_utf16le(const char16_t *buf, size_t len) const noexcept {
26180   const char16_t* tail = avx2_validate_utf16<endianness::LITTLE>(buf, len);
26182     return scalar::utf16::validate<endianness::LITTLE>(tail, len - (tail - buf));
26188 simdutf_warn_unused bool implementation::validate_utf16be(const char16_t *buf, size_t len) const noexcept {
26189   const char16_t* tail = avx2_validate_utf16<endianness::BIG>(buf, len);
26191     return scalar::utf16::validate<endianness::BIG>(tail, len - (tail - buf));
26197 simdutf_warn_unused result implementation::validate_utf16le_with_errors(const char16_t *buf, size_t len) const noexcept {
26198   result res = avx2_validate_utf16_with_errors<endianness::LITTLE>(buf, len);
26199   if (res.count != len) {
26200     result scalar_res = scalar::utf16::validate_with_errors<endianness::LITTLE>(buf + res.count, len - res.count);
26207 simdutf_warn_unused result implementation::validate_utf16be_with_errors(const char16_t *buf, size_t len) const noexcept {
26208   result res = avx2_validate_utf16_with_errors<endianness::BIG>(buf, len);
26209   if (res.count != len) {
26210     result scalar_res = scalar::utf16::validate_with_errors<endianness::BIG>(buf + res.count, len - res.count);
26217 simdutf_warn_unused bool implementation::validate_utf32(const char32_t *buf, size_t len) const noexcept {
26218   const char32_t* tail = avx2_validate_utf32le(buf, len);
26220     return scalar::utf32::validate(tail, len - (tail - buf));
26226 simdutf_warn_unused result implementation::validate_utf32_with_errors(const char32_t *buf, size_t len) const noexcept {
26227   result res = avx2_validate_utf32le_with_errors(buf, len);
26228   if (res.count != len) {
26229     result scalar_res = scalar::utf32::validate_with_errors(buf + res.count, len - res.count);
26236 simdutf_warn_unused size_t implementation::convert_latin1_to_utf8(const char * buf, size_t len, char* utf8_output) const noexcept {
26237   std::pair<const char*, char*> ret = avx2_convert_latin1_to_utf8(buf, len, utf8_output);
26240   if (ret.first != buf + len) {
26242       ret.first, len - (ret.first - buf), ret.second);
26249 simdutf_warn_unused size_t implementation::convert_latin1_to_utf16le(const char* buf, size_t len, char16_t* utf16_output) const noexcept {
26250     std::pair<const char*, char16_t*> ret = avx2_convert_latin1_to_utf16<endianness::LITTLE>(buf, len, utf16_output);
26253     if (ret.first != buf + len) {
26255                                               ret.first, len - (ret.first - buf), ret.second);
26262 simdutf_warn_unused size_t implementation::convert_latin1_to_utf16be(const char* buf, size_t len, char16_t* utf16_output) const noexcept {
26263     std::pair<const char*, char16_t*> ret = avx2_convert_latin1_to_utf16<endianness::BIG>(buf, len, utf16_output);
26266     if (ret.first != buf + len) {
26268                                               ret.first, len - (ret.first - buf), ret.second);
26275 simdutf_warn_unused size_t implementation::convert_latin1_to_utf32(const char* buf, size_t len, char32_t* utf32_output) const noexcept {
26276     std::pair<const char*, char32_t*> ret = avx2_convert_latin1_to_utf32(buf, len, utf32_output);
26279     if (ret.first != buf + len) {
26281                                               ret.first, len - (ret.first - buf), ret.second);
26288 simdutf_warn_unused size_t implementation::convert_utf8_to_latin1(const char* buf, size_t len, char* latin1_output) const noexcept {
26290   return converter.convert(buf, len, latin1_output);
26293 simdutf_warn_unused result implementation::convert_utf8_to_latin1_with_errors(const char* buf, size_t len, char* latin1_output) const noexcept {
26295   return converter.convert_with_errors(buf, len, latin1_output);
26303 simdutf_warn_unused size_t implementation::convert_utf8_to_utf16le(const char* buf, size_t len, char16_t* utf16_output) const noexcept {
26305   return converter.convert<endianness::LITTLE>(buf, len, utf16_output);
26308 simdutf_warn_unused size_t implementation::convert_utf8_to_utf16be(const char* buf, size_t len, char16_t* utf16_output) const noexcept {
26310   return converter.convert<endianness::BIG>(buf, len, utf16_output);
26313 simdutf_warn_unused result implementation::convert_utf8_to_utf16le_with_errors(const char* buf, size_t len, char16_t* utf16_output) const noexcept {
26315   return converter.convert_with_errors<endianness::LITTLE>(buf, len, utf16_output);
26318 simdutf_warn_unused result implementation::convert_utf8_to_utf16be_with_errors(const char* buf, size_t len, char16_t* utf16_output) const noexcept {
26320   return converter.convert_with_errors<endianness::BIG>(buf, len, utf16_output);
26333 simdutf_warn_unused size_t implementation::convert_utf8_to_utf32(const char* buf, size_t len, char32_t* utf32_output) const noexcept {
26335   return converter.convert(buf, len, utf32_output);
26338 simdutf_warn_unused result implementation::convert_utf8_to_utf32_with_errors(const char* buf, size_t len, char32_t* utf32_output) const noexcept {
26340   return converter.convert_with_errors(buf, len, utf32_output);
26349 simdutf_warn_unused size_t implementation::convert_utf16le_to_latin1(const char16_t* buf, size_t len, char* latin1_output) const noexcept {
26350   std::pair<const char16_t*, char*> ret = haswell::avx2_convert_utf16_to_latin1<endianness::LITTLE>(buf, len, latin1_output);
26353   if (ret.first != buf + len) {
26355                                         ret.first, len - (ret.first - buf), ret.second);
26362 simdutf_warn_unused size_t implementation::convert_utf16be_to_latin1(const char16_t* buf, size_t len, char* latin1_output) const noexcept {
26363   std::pair<const char16_t*, char*> ret = haswell::avx2_convert_utf16_to_latin1<endianness::BIG>(buf, len, latin1_output);
26366   if (ret.first != buf + len) {
26368                                         ret.first, len - (ret.first - buf), ret.second);
26375 simdutf_warn_unused result implementation::convert_utf16le_to_latin1_with_errors(const char16_t* buf, size_t len, char* latin1_output) const noexcept {
26376   std::pair<result, char*> ret = avx2_convert_utf16_to_latin1_with_errors<endianness::LITTLE>(buf, len, latin1_output);
26378   if (ret.first.count != len) { // All good so far, but not finished
26380                                         buf + ret.first.count, len - ret.first.count, ret.second);
26392 simdutf_warn_unused result implementation::convert_utf16be_to_latin1_with_errors(const char16_t* buf, size_t len, char* latin1_output) const noexcept {
26393   std::pair<result, char*> ret = avx2_convert_utf16_to_latin1_with_errors<endianness::BIG>(buf, len, latin1_output);
26395   if (ret.first.count != len) { // All good so far, but not finished
26397                                         buf + ret.first.count, len - ret.first.count, ret.second);
26409 simdutf_warn_unused size_t implementation::convert_valid_utf16be_to_latin1(const char16_t* buf, size_t len, char* latin1_output) const noexcept {
26411   return convert_utf16be_to_latin1(buf, len, latin1_output);
26414 simdutf_warn_unused size_t implementation::convert_valid_utf16le_to_latin1(const char16_t* buf, size_t len, char* latin1_output) const noexcept {
26416   return convert_utf16le_to_latin1(buf, len, latin1_output);
26419 simdutf_warn_unused size_t implementation::convert_utf16le_to_utf8(const char16_t* buf, size_t len, char* utf8_output) const noexcept {
26420   std::pair<const char16_t*, char*> ret = haswell::avx2_convert_utf16_to_utf8<endianness::LITTLE>(buf, len, utf8_output);
26423   if (ret.first != buf + len) {
26425                                         ret.first, len - (ret.first - buf), ret.second);
26432 simdutf_warn_unused size_t implementation::convert_utf16be_to_utf8(const char16_t* buf, size_t len, char* utf8_output) const noexcept {
26433   std::pair<const char16_t*, char*> ret = haswell::avx2_convert_utf16_to_utf8<endianness::BIG>(buf, len, utf8_output);
26436   if (ret.first != buf + len) {
26438                                         ret.first, len - (ret.first - buf), ret.second);
26445 simdutf_warn_unused result implementation::convert_utf16le_to_utf8_with_errors(const char16_t* buf, size_t len, char* utf8_output) const noexcept {
26447   std::pair<result, char*> ret = haswell::avx2_convert_utf16_to_utf8_with_errors<endianness::LITTLE>(buf, len, utf8_output);
26449   if (ret.first.count != len) { // All good so far, but not finished
26451                                         buf + ret.first.count, len - ret.first.count, ret.second);
26463 simdutf_warn_unused result implementation::convert_utf16be_to_utf8_with_errors(const char16_t* buf, size_t len, char* utf8_output) const noexcept {
26465   std::pair<result, char*> ret = haswell::avx2_convert_utf16_to_utf8_with_errors<endianness::BIG>(buf, len, utf8_output);
26467   if (ret.first.count != len) { // All good so far, but not finished
26469                                         buf + ret.first.count, len - ret.first.count, ret.second);
26481 simdutf_warn_unused size_t implementation::convert_valid_utf16le_to_utf8(const char16_t* buf, size_t len, char* utf8_output) const noexcept {
26482   return convert_utf16le_to_utf8(buf, len, utf8_output);
26485 simdutf_warn_unused size_t implementation::convert_valid_utf16be_to_utf8(const char16_t* buf, size_t len, char* utf8_output) const noexcept {
26486   return convert_utf16be_to_utf8(buf, len, utf8_output);
26489 simdutf_warn_unused size_t implementation::convert_utf32_to_utf8(const char32_t* buf, size_t len, char* utf8_output) const noexcept {
26490   std::pair<const char32_t*, char*> ret = avx2_convert_utf32_to_utf8(buf, len, utf8_output);
26493   if (ret.first != buf + len) {
26495                                         ret.first, len - (ret.first - buf), ret.second);
26502 simdutf_warn_unused size_t implementation::convert_utf32_to_latin1(const char32_t* buf, size_t len, char* latin1_output) const noexcept {
26503   std::pair<const char32_t*, char*> ret = avx2_convert_utf32_to_latin1(buf, len, latin1_output);
26506   if (ret.first != buf + len) {
26508                                         ret.first, len - (ret.first - buf), ret.second);
26515 simdutf_warn_unused result implementation::convert_utf32_to_latin1_with_errors(const char32_t* buf, size_t len, char* latin1_output) const noexcept {
26517   std::pair<result, char*> ret = avx2_convert_utf32_to_latin1_with_errors(buf, len, latin1_output);
26518   if (ret.first.count != len) {
26520                                         buf + ret.first.count, len - ret.first.count, ret.second);
26532 simdutf_warn_unused size_t implementation::convert_valid_utf32_to_latin1(const char32_t* buf, size_t len, char* latin1_output) const noexcept {
26533   return convert_utf32_to_latin1(buf,len,latin1_output);
26536 simdutf_warn_unused result implementation::convert_utf32_to_utf8_with_errors(const char32_t* buf, size_t len, char* utf8_output) const noexcept {
26538   std::pair<result, char*> ret = haswell::avx2_convert_utf32_to_utf8_with_errors(buf, len, utf8_output);
26539   if (ret.first.count != len) {
26541                                         buf + ret.first.count, len - ret.first.count, ret.second);
26553 simdutf_warn_unused size_t implementation::convert_utf16le_to_utf32(const char16_t* buf, size_t len, char32_t* utf32_output) const noexcept {
26554   std::pair<const char16_t*, char32_t*> ret = haswell::avx2_convert_utf16_to_utf32<endianness::LITTLE>(buf, len, utf32_output);
26557   if (ret.first != buf + len) {
26559                                         ret.first, len - (ret.first - buf), ret.second);
26566 simdutf_warn_unused size_t implementation::convert_utf16be_to_utf32(const char16_t* buf, size_t len, char32_t* utf32_output) const noexcept {
26567   std::pair<const char16_t*, char32_t*> ret = haswell::avx2_convert_utf16_to_utf32<endianness::BIG>(buf, len, utf32_output);
26570   if (ret.first != buf + len) {
26572                                         ret.first, len - (ret.first - buf), ret.second);
26579 simdutf_warn_unused result implementation::convert_utf16le_to_utf32_with_errors(const char16_t* buf, size_t len, char32_t* utf32_output) const noexcept {
26581   std::pair<result, char32_t*> ret = haswell::avx2_convert_utf16_to_utf32_with_errors<endianness::LITTLE>(buf, len, utf32_output);
26583   if (ret.first.count != len) { // All good so far, but not finished
26585                                         buf + ret.first.count, len - ret.first.count, ret.second);
26597 simdutf_warn_unused result implementation::convert_utf16be_to_utf32_with_errors(const char16_t* buf, size_t len, char32_t* utf32_output) const noexcept {
26599   std::pair<result, char32_t*> ret = haswell::avx2_convert_utf16_to_utf32_with_errors<endianness::BIG>(buf, len, utf32_output);
26601   if (ret.first.count != len) { // All good so far, but not finished
26603                                         buf + ret.first.count, len - ret.first.count, ret.second);
26615 simdutf_warn_unused size_t implementation::convert_valid_utf32_to_utf8(const char32_t* buf, size_t len, char* utf8_output) const noexcept {
26616   return convert_utf32_to_utf8(buf, len, utf8_output);
26619 simdutf_warn_unused size_t implementation::convert_utf32_to_utf16le(const char32_t* buf, size_t len, char16_t* utf16_output) const noexcept {
26620   std::pair<const char32_t*, char16_t*> ret = avx2_convert_utf32_to_utf16<endianness::LITTLE>(buf, len, utf16_output);
26623   if (ret.first != buf + len) {
26625                                         ret.first, len - (ret.first - buf), ret.second);
26632 simdutf_warn_unused size_t implementation::convert_utf32_to_utf16be(const char32_t* buf, size_t len, char16_t* utf16_output) const noexcept {
26633   std::pair<const char32_t*, char16_t*> ret = avx2_convert_utf32_to_utf16<endianness::BIG>(buf, len, utf16_output);
26636   if (ret.first != buf + len) {
26638                                         ret.first, len - (ret.first - buf), ret.second);
26645 simdutf_warn_unused result implementation::convert_utf32_to_utf16le_with_errors(const char32_t* buf, size_t len, char16_t* utf16_output) const noexcept {
26647   std::pair<result, char16_t*> ret = haswell::avx2_convert_utf32_to_utf16_with_errors<endianness::LITTLE>(buf, len, utf16_output);
26648   if (ret.first.count != len) {
26650                                         buf + ret.first.count, len - ret.first.count, ret.second);
26662 simdutf_warn_unused result implementation::convert_utf32_to_utf16be_with_errors(const char32_t* buf, size_t len, char16_t* utf16_output) const noexcept {
26664   std::pair<result, char16_t*> ret = haswell::avx2_convert_utf32_to_utf16_with_errors<endianness::BIG>(buf, len, utf16_output);
26665   if (ret.first.count != len) {
26667                                         buf + ret.first.count, len - ret.first.count, ret.second);
26679 simdutf_warn_unused size_t implementation::convert_valid_utf32_to_utf16le(const char32_t* buf, size_t len, char16_t* utf16_output) const noexcept {
26680   return convert_utf32_to_utf16le(buf, len, utf16_output);
26683 simdutf_warn_unused size_t implementation::convert_valid_utf32_to_utf16be(const char32_t* buf, size_t len, char16_t* utf16_output) const noexcept {
26684   return convert_utf32_to_utf16be(buf, len, utf16_output);
26687 simdutf_warn_unused size_t implementation::convert_valid_utf16le_to_utf32(const char16_t* buf, size_t len, char32_t* utf32_output) const noexcept {
26688   return convert_utf16le_to_utf32(buf, len, utf32_output);
26691 simdutf_warn_unused size_t implementation::convert_valid_utf16be_to_utf32(const char16_t* buf, size_t len, char32_t* utf32_output) const noexcept {
26692   return convert_utf16be_to_utf32(buf, len, utf32_output);
26711 simdutf_warn_unused size_t implementation::latin1_length_from_utf8(const char* buf, size_t len) const noexcept {
26712   return count_utf8(buf,len);
26753 simdutf_warn_unused size_t implementation::utf8_length_from_latin1(const char *input, size_t len) const noexcept {
26755   size_t answer = len / sizeof(__m256i) * sizeof(__m256i);
26758   while (i + sizeof(__m256i) <= len) {
26761     size_t iterations = (len - i) / sizeof(__m256i);
26791   return answer + scalar::latin1::utf8_length_from_latin1(reinterpret_cast<const char *>(data + i), len - i);
26916    * There will always be a last block, with at least 1 byte, unless len == 0 (in which case this
26917    * function fills the buffer with spaces and returns 0. In particular, if len == STEP_SIZE there
26926   const size_t len;
26962 simdutf_really_inline buf_block_reader<STEP_SIZE>::buf_block_reader(const uint8_t *_buf, size_t _len) : buf{_buf}, len{_len}, lenminusstep{len < STEP_SIZE ? 0 : len - STEP_SIZE}, idx{0} {}
26979   if(len == idx) { return 0; } // memcpy(dst, null, 0) will trigger an error with some sanitizers
26981   std::memcpy(dst, buf + idx, len - idx);
26982   return len - idx;
28162 simdutf_warn_unused bool implementation::validate_utf8(const char *buf, size_t len) const noexcept {
28163   return ppc64::utf8_validation::generic_validate_utf8(buf,len);
28166 simdutf_warn_unused result implementation::validate_utf8_with_errors(const char *buf, size_t len) const noexcept {
28167   return ppc64::utf8_validation::generic_validate_utf8_with_errors(buf,len);
28170 simdutf_warn_unused bool implementation::validate_ascii(const char *buf, size_t len) const noexcept {
28171   return ppc64::utf8_validation::generic_validate_ascii(buf,len);
28174 simdutf_warn_unused result implementation::validate_ascii_with_errors(const char *buf, size_t len) const noexcept {
28175   return ppc64::utf8_validation::generic_validate_ascii_with_errors(buf,len);
28178 simdutf_warn_unused bool implementation::validate_utf16le(const char16_t *buf, size_t len) const noexcept {
28179   return scalar::utf16::validate<endianness::LITTLE>(buf, len);
28182 simdutf_warn_unused bool implementation::validate_utf16be(const char16_t *buf, size_t len) const noexcept {
28183   return scalar::utf16::validate<endianness::BIG>(buf, len);
28186 simdutf_warn_unused result implementation::validate_utf16le_with_errors(const char16_t *buf, size_t len) const noexcept {
28187   return scalar::utf16::validate_with_errors<endianness::LITTLE>(buf, len);
28190 simdutf_warn_unused result implementation::validate_utf16be_with_errors(const char16_t *buf, size_t len) const noexcept {
28191   return scalar::utf16::validate_with_errors<endianness::BIG>(buf, len);
28194 simdutf_warn_unused result implementation::validate_utf32_with_errors(const char32_t *buf, size_t len) const noexcept {
28195   return scalar::utf32::validate_with_errors(buf, len);
28198 simdutf_warn_unused bool implementation::validate_utf32(const char16_t *buf, size_t len) const noexcept {
28199   return scalar::utf32::validate(buf, len);
28202 simdutf_warn_unused size_t implementation::convert_utf8_to_utf16le(const char* /*buf*/, size_t /*len*/, char16_t* /*utf16_output*/) const noexcept {
28206 simdutf_warn_unused size_t implementation::convert_utf8_to_utf16be(const char* /*buf*/, size_t /*len*/, char16_t* /*utf16_output*/) const noexcept {
28210 simdutf_warn_unused result implementation::convert_utf8_to_utf16le_with_errors(const char* /*buf*/, size_t /*len*/, char16_t* /*utf16_output*/) const noexcept {
28214 simdutf_warn_unused result implementation::convert_utf8_to_utf16be_with_errors(const char* /*buf*/, size_t /*len*/, char16_t* /*utf16_output*/) const noexcept {
28218 simdutf_warn_unused size_t implementation::convert_valid_utf8_to_utf16le(const char* /*buf*/, size_t /*len*/, char16_t* /*utf16_output*/) const noexcept {
28222 simdutf_warn_unused size_t implementation::convert_valid_utf8_to_utf16be(const char* /*buf*/, size_t /*len*/, char16_t* /*utf16_output*/) const noexcept {
28226 simdutf_warn_unused size_t implementation::convert_utf8_to_utf32(const char* /*buf*/, size_t /*len*/, char32_t* /*utf16_output*/) const noexcept {
28230 simdutf_warn_unused result implementation::convert_utf8_to_utf32_with_errors(const char* /*buf*/, size_t /*len*/, char32_t* /*utf16_output*/) const noexcept {
28234 simdutf_warn_unused size_t implementation::convert_valid_utf8_to_utf32(const char* /*buf*/, size_t /*len*/, char32_t* /*utf16_output*/) const noexcept {
28238 simdutf_warn_unused size_t implementation::convert_utf16le_to_utf8(const char16_t* buf, size_t len, char* utf8_output) const noexcept {
28239   return scalar::utf16_to_utf8::convert<endianness::LITTLE>(buf, len, utf8_output);
28242 simdutf_warn_unused size_t implementation::convert_utf16be_to_utf8(const char16_t* buf, size_t len, char* utf8_output) const noexcept {
28243   return scalar::utf16_to_utf8::convert<endianness::BIG>(buf, len, utf8_output);
28246 simdutf_warn_unused result implementation::convert_utf16le_to_utf8_with_errors(const char16_t* buf, size_t len, char* utf8_output) const noexcept {
28247   return scalar::utf16_to_utf8::convert_with_errors<endianness::LITTLE>(buf, len, utf8_output);
28250 simdutf_warn_unused result implementation::convert_utf16be_to_utf8_with_errors(const char16_t* buf, size_t len, char* utf8_output) const noexcept {
28251   return scalar::utf16_to_utf8::convert_with_errors<endianness::BIG>(buf, len, utf8_output);
28254 simdutf_warn_unused size_t implementation::convert_valid_utf16le_to_utf8(const char16_t* buf, size_t len, char* utf8_output) const noexcept {
28255   return scalar::utf16_to_utf8::convert_valid<endianness::LITTLE>(buf, len, utf8_output);
28258 simdutf_warn_unused size_t implementation::convert_valid_utf16be_to_utf8(const char16_t* buf, size_t len, char* utf8_output) const noexcept {
28259   return scalar::utf16_to_utf8::convert_valid<endianness::BIG>(buf, len, utf8_output);
28262 simdutf_warn_unused size_t implementation::convert_utf32_to_utf8(const char32_t* buf, size_t len, char* utf8_output) const noexcept {
28263   return scalar::utf32_to_utf8::convert(buf, len, utf8_output);
28266 simdutf_warn_unused result implementation::convert_utf32_to_utf8_with_errors(const char32_t* buf, size_t len, char* utf8_output) const noexcept {
28267   return scalar::utf32_to_utf8::convert_with_errors(buf, len, utf8_output);
28270 simdutf_warn_unused size_t implementation::convert_valid_utf32_to_utf8(const char32_t* buf, size_t len, char* utf8_output) const noexcept {
28271   return scalar::utf32_to_utf8::convert_valid(buf, len, utf8_output);
28274 simdutf_warn_unused size_t implementation::convert_utf32_to_utf16le(const char32_t* buf, size_t len, char16_t* utf16_output) const noexcept {
28275   return scalar::utf32_to_utf16::convert<endianness::LITTLE>(buf, len, utf16_output);
28278 simdutf_warn_unused size_t implementation::convert_utf32_to_utf16be(const char32_t* buf, size_t len, char16_t* utf16_output) const noexcept {
28279   return scalar::utf32_to_utf16::convert<endianness::BIG>(buf, len, utf16_output);
28282 simdutf_warn_unused result implementation::convert_utf32_to_utf16le_with_errors(const char32_t* buf, size_t len, char16_t* utf16_output) const noexcept {
28283   return scalar::utf32_to_utf16::convert_with_errors<endianness::LITTLE>(buf, len, utf16_output);
28286 simdutf_warn_unused result implementation::convert_utf32_to_utf16be_with_errors(const char32_t* buf, size_t len, char16_t* utf16_output) const noexcept {
28287   return scalar::utf32_to_utf16::convert_with_errors<endianness::BIG>(buf, len, utf16_output);
28290 simdutf_warn_unused size_t implementation::convert_valid_utf32_to_utf16le(const char32_t* buf, size_t len, char16_t* utf16_output) const noexcept {
28291   return scalar::utf32_to_utf16::convert_valid<endianness::LITTLE>(buf, len, utf16_output);
28294 simdutf_warn_unused size_t implementation::convert_valid_utf32_to_utf16be(const char32_t* buf, size_t len, char16_t* utf16_output) const noexcept {
28295   return scalar::utf32_to_utf16::convert_valid<endianness::BIG>(buf, len, utf16_output);
28298 simdutf_warn_unused size_t implementation::convert_utf16le_to_utf32(const char16_t* buf, size_t len, char32_t* utf32_output) const noexcept {
28299   return scalar::utf16_to_utf32::convert<endianness::LITTLE>(buf, len, utf32_output);
28302 simdutf_warn_unused size_t implementation::convert_utf16be_to_utf32(const char16_t* buf, size_t len, char32_t* utf32_output) const noexcept {
28303   return scalar::utf16_to_utf32::convert<endianness::BIG>(buf, len, utf32_output);
28306 simdutf_warn_unused result implementation::convert_utf16le_to_utf32_with_errors(const char16_t* buf, size_t len, char32_t* utf32_output) const noexcept {
28307   return scalar::utf16_to_utf32::convert_with_errors<endianness::LITTLE>(buf, len, utf32_output);
28310 simdutf_warn_unused result implementation::convert_utf16be_to_utf32_with_errors(const char16_t* buf, size_t len, char32_t* utf32_output) const noexcept {
28311   return scalar::utf16_to_utf32::convert_with_errors<endianness::BIG>(buf, len, utf32_output);
28314 simdutf_warn_unused size_t implementation::convert_valid_utf16le_to_utf32(const char16_t* buf, size_t len, char32_t* utf32_output) const noexcept {
28315   return scalar::utf16_to_utf32::convert_valid<endianness::LITTLE>(buf, len, utf32_output);
28318 simdutf_warn_unused size_t implementation::convert_valid_utf16be_to_utf32(const char16_t* buf, size_t len, char32_t* utf32_output) const noexcept {
28319   return scalar::utf16_to_utf32::convert_valid<endianness::BIG>(buf, len, utf32_output);
28496 // len is known to be a multiple of 2 when this is called
28497 int sse_detect_encodings(const char * buf, size_t len) {
28499     const char* end = buf + len;
28553                 const char16_t* end16 = reinterpret_cast<const char16_t*>(start) + len/2;
28620                 if (len % 4 == 0) {
28622                     const char32_t* end32 = reinterpret_cast<const char32_t*>(start) + len/4;
28675         if (static_cast<size_t>(buf - start) != len) {
28678             std::memcpy(block, buf, len - (buf - start));
28687     if (is_utf16 && scalar::utf16::validate<endianness::LITTLE>(reinterpret_cast<const char16_t*>(buf), (len - (buf - start))/2)) {
28691     if (is_utf32 && (len % 4 == 0)) {
28694         if (_mm_testz_si128(is_zero, is_zero) == 1 && scalar::utf32::validate(reinterpret_cast<const char32_t*>(buf), (len - (buf - start))/4)) {
29053 std::pair<const char*, char16_t*> sse_convert_latin1_to_utf16(const char *latin1_input, size_t len,
29055     size_t rounded_len = len & ~0xF; // Round down to nearest multiple of 16
29072 std::pair<const char*, char32_t*> sse_convert_latin1_to_utf32(const char* buf, size_t len, char32_t* utf32_output) {
29073     const char* end = buf + len;
29478 std::pair<const char16_t*, char*> sse_convert_utf16_to_latin1(const char16_t* buf, size_t len, char* latin1_output) {
29479   const char16_t* end = buf + len;
29505 std::pair<result, char*> sse_convert_utf16_to_latin1_with_errors(const char16_t* buf, size_t len, char* latin1_output) {
29507   const char16_t* end = buf + len;
29593 std::pair<const char16_t*, char*> sse_convert_utf16_to_utf8(const char16_t* buf, size_t len, char* utf8_output) {
29595   const char16_t* end = buf + len;
29797 std::pair<result, char*> sse_convert_utf16_to_utf8_with_errors(const char16_t* buf, size_t len, char* utf8_output) {
29799   const char16_t* end = buf + len;
30048 std::pair<const char16_t*, char32_t*> sse_convert_utf16_to_utf32(const char16_t* buf, size_t len, char32_t* utf32_output) {
30049   const char16_t* end = buf + len;
30115 std::pair<result, char32_t*> sse_convert_utf16_to_utf32_with_errors(const char16_t* buf, size_t len, char32_t* utf32_output) {
30117   const char16_t* end = buf + len;
30178 sse_convert_utf32_to_latin1(const char32_t *buf, size_t len,
30180   const size_t rounded_len = len & ~0xF; // Round down to nearest multiple of 16
30211 sse_convert_utf32_to_latin1_with_errors(const char32_t *buf, size_t len,
30214   const size_t rounded_len = len & ~0xF; // Round down to nearest multiple of 16
30257 std::pair<const char32_t*, char*> sse_convert_utf32_to_utf8(const char32_t* buf, size_t len, char* utf8_output) {
30258   const char32_t* end = buf + len;
30516 std::pair<result, char*> sse_convert_utf32_to_utf8_with_errors(const char32_t* buf, size_t len, char* utf8_output) {
30518   const char32_t* end = buf + len;
30771 std::pair<const char32_t*, char16_t*> sse_convert_utf32_to_utf16(const char32_t* buf, size_t len, char16_t* utf16_output) {
30773   const char32_t* end = buf + len;
30838 std::pair<result, char16_t*> sse_convert_utf32_to_utf16_with_errors(const char32_t* buf, size_t len, char16_t* utf16_output) {
30840   const char32_t* end = buf + len;
30923    * There will always be a last block, with at least 1 byte, unless len == 0 (in which case this
30924    * function fills the buffer with spaces and returns 0. In particular, if len == STEP_SIZE there
30933   const size_t len;
30969 simdutf_really_inline buf_block_reader<STEP_SIZE>::buf_block_reader(const uint8_t *_buf, size_t _len) : buf{_buf}, len{_len}, lenminusstep{len < STEP_SIZE ? 0 : len - STEP_SIZE}, idx{0} {}
30986   if(len == idx) { return 0; } // memcpy(dst, null, 0) will trigger an error with some sanitizers
30988   std::memcpy(dst, buf + idx, len - idx);
30989   return len - idx;
32545 simdutf_warn_unused bool implementation::validate_utf8(const char *buf, size_t len) const noexcept {
32546   return westmere::utf8_validation::generic_validate_utf8(buf, len);
32549 simdutf_warn_unused result implementation::validate_utf8_with_errors(const char *buf, size_t len) const noexcept {
32550   return westmere::utf8_validation::generic_validate_utf8_with_errors(buf, len);
32553 simdutf_warn_unused bool implementation::validate_ascii(const char *buf, size_t len) const noexcept {
32554   return westmere::utf8_validation::generic_validate_ascii(buf, len);
32557 simdutf_warn_unused result implementation::validate_ascii_with_errors(const char *buf, size_t len) const noexcept {
32558   return westmere::utf8_validation::generic_validate_ascii_with_errors(buf,len);
32561 simdutf_warn_unused bool implementation::validate_utf16le(const char16_t *buf, size_t len) const noexcept {
32562   const char16_t* tail = sse_validate_utf16<endianness::LITTLE>(buf, len);
32564     return scalar::utf16::validate<endianness::LITTLE>(tail, len - (tail - buf));
32570 simdutf_warn_unused bool implementation::validate_utf16be(const char16_t *buf, size_t len) const noexcept {
32571   const char16_t* tail = sse_validate_utf16<endianness::BIG>(buf, len);
32573     return scalar::utf16::validate<endianness::BIG>(tail, len - (tail - buf));
32579 simdutf_warn_unused result implementation::validate_utf16le_with_errors(const char16_t *buf, size_t len) const noexcept {
32580   result res = sse_validate_utf16_with_errors<endianness::LITTLE>(buf, len);
32581   if (res.count != len) {
32582     result scalar_res = scalar::utf16::validate_with_errors<endianness::LITTLE>(buf + res.count, len - res.count);
32589 simdutf_warn_unused result implementation::validate_utf16be_with_errors(const char16_t *buf, size_t len) const noexcept {
32590   result res = sse_validate_utf16_with_errors<endianness::BIG>(buf, len);
32591   if (res.count != len) {
32592     result scalar_res = scalar::utf16::validate_with_errors<endianness::BIG>(buf + res.count, len - res.count);
32599 simdutf_warn_unused bool implementation::validate_utf32(const char32_t *buf, size_t len) const noexcept {
32600   const char32_t* tail = sse_validate_utf32le(buf, len);
32602     return scalar::utf32::validate(tail, len - (tail - buf));
32608 simdutf_warn_unused result implementation::validate_utf32_with_errors(const char32_t *buf, size_t len) const noexcept {
32609   result res = sse_validate_utf32le_with_errors(buf, len);
32610   if (res.count != len) {
32611     result scalar_res = scalar::utf32::validate_with_errors(buf + res.count, len - res.count);
32618 simdutf_warn_unused size_t implementation::convert_latin1_to_utf8(const char * buf, size_t len, char* utf8_output) const noexcept {
32620   std::pair<const char*, char*> ret = sse_convert_latin1_to_utf8(buf, len, utf8_output);
32623   if (ret.first != buf + len) {
32625       ret.first, len - (ret.first - buf), ret.second);
32632 simdutf_warn_unused size_t implementation::convert_latin1_to_utf16le(const char* buf, size_t len, char16_t* utf16_output) const noexcept {
32633     std::pair<const char*, char16_t*> ret = sse_convert_latin1_to_utf16<endianness::LITTLE>(buf, len, utf16_output);
32636     if (ret.first != buf + len) {
32638                                               ret.first, len - (ret.first - buf), ret.second);
32645 simdutf_warn_unused size_t implementation::convert_latin1_to_utf16be(const char* buf, size_t len, char16_t* utf16_output) const noexcept {
32646     std::pair<const char*, char16_t*> ret = sse_convert_latin1_to_utf16<endianness::BIG>(buf, len, utf16_output);
32649     if (ret.first != buf + len) {
32651                                               ret.first, len - (ret.first - buf), ret.second);
32658 simdutf_warn_unused size_t implementation::convert_latin1_to_utf32(const char* buf, size_t len, char32_t* utf32_output) const noexcept {
32659     std::pair<const char*, char32_t*> ret = sse_convert_latin1_to_utf32(buf, len, utf32_output);
32662     if (ret.first != buf + len) {
32664                                               ret.first, len - (ret.first - buf), ret.second);
32672 simdutf_warn_unused size_t implementation::convert_utf8_to_latin1(const char* buf, size_t len, char* latin1_output) const noexcept {
32674   return converter.convert(buf, len, latin1_output);
32677 simdutf_warn_unused result implementation::convert_utf8_to_latin1_with_errors(const char* buf, size_t len, char* latin1_output) const noexcept {
32679   return converter.convert_with_errors(buf, len, latin1_output);
32682 simdutf_warn_unused size_t implementation::convert_valid_utf8_to_latin1(const char* buf, size_t len, char* latin1_output) const noexcept {
32683   return westmere::utf8_to_latin1::convert_valid(buf,len,latin1_output);
32686 simdutf_warn_unused size_t implementation::convert_utf8_to_utf16le(const char* buf, size_t len, char16_t* utf16_output) const noexcept {
32688   return converter.convert<endianness::LITTLE>(buf, len, utf16_output);
32691 simdutf_warn_unused size_t implementation::convert_utf8_to_utf16be(const char* buf, size_t len, char16_t* utf16_output) const noexcept {
32693   return converter.convert<endianness::BIG>(buf, len, utf16_output);
32696 simdutf_warn_unused result implementation::convert_utf8_to_utf16le_with_errors(const char* buf, size_t len, char16_t* utf16_output) const noexcept {
32698   return converter.convert_with_errors<endianness::LITTLE>(buf, len, utf16_output);
32701 simdutf_warn_unused result implementation::convert_utf8_to_utf16be_with_errors(const char* buf, size_t len, char16_t* utf16_output) const noexcept {
32703   return converter.convert_with_errors<endianness::BIG>(buf, len, utf16_output);
32717 simdutf_warn_unused size_t implementation::convert_utf8_to_utf32(const char* buf, size_t len, char32_t* utf32_output) const noexcept {
32719   return converter.convert(buf, len, utf32_output);
32722 simdutf_warn_unused result implementation::convert_utf8_to_utf32_with_errors(const char* buf, size_t len, char32_t* utf32_output) const noexcept {
32724   return converter.convert_with_errors(buf, len, utf32_output);
32732 simdutf_warn_unused size_t implementation::convert_utf16le_to_latin1(const char16_t* buf, size_t len, char* latin1_output) const noexcept {
32733   std::pair<const char16_t*, char*> ret = sse_convert_utf16_to_latin1<endianness::LITTLE>(buf, len, latin1_output);
32737   if (ret.first != buf + len) {
32739                                         ret.first, len - (ret.first - buf), ret.second);
32746 simdutf_warn_unused size_t implementation::convert_utf16be_to_latin1(const char16_t* buf, size_t len, char* latin1_output) const noexcept {
32747   std::pair<const char16_t*, char*> ret = sse_convert_utf16_to_latin1<endianness::BIG>(buf, len, latin1_output);
32751   if (ret.first != buf + len) {
32753                                         ret.first, len - (ret.first - buf), ret.second);
32760 simdutf_warn_unused result implementation::convert_utf16le_to_latin1_with_errors(const char16_t* buf, size_t len, char* latin1_output) const noexcept {
32761   std::pair<result, char*> ret = sse_convert_utf16_to_latin1_with_errors<endianness::LITTLE>(buf, len, latin1_output);
32763   if (ret.first.count != len) { // All good so far, but not finished
32765                                         buf + ret.first.count, len - ret.first.count, ret.second);
32777 simdutf_warn_unused result implementation::convert_utf16be_to_latin1_with_errors(const char16_t* buf, size_t len, char* latin1_output) const noexcept {
32778   std::pair<result, char*> ret = sse_convert_utf16_to_latin1_with_errors<endianness::BIG>(buf, len, latin1_output);
32780   if (ret.first.count != len) { // All good so far, but not finished
32782                                         buf + ret.first.count, len - ret.first.count, ret.second);
32795 simdutf_warn_unused size_t implementation::convert_valid_utf16be_to_latin1(const char16_t* buf, size_t len, char* latin1_output) const noexcept {
32797   return convert_utf16be_to_latin1(buf, len, latin1_output);
32800 simdutf_warn_unused size_t implementation::convert_valid_utf16le_to_latin1(const char16_t* buf, size_t len, char* latin1_output) const noexcept {
32802   return convert_utf16le_to_latin1(buf, len, latin1_output);
32805 simdutf_warn_unused size_t implementation::convert_utf16le_to_utf8(const char16_t* buf, size_t len, char* utf8_output) const noexcept {
32806   std::pair<const char16_t*, char*> ret = sse_convert_utf16_to_utf8<endianness::LITTLE>(buf, len, utf8_output);
32809   if (ret.first != buf + len) {
32811                                         ret.first, len - (ret.first - buf), ret.second);
32818 simdutf_warn_unused size_t implementation::convert_utf16be_to_utf8(const char16_t* buf, size_t len, char* utf8_output) const noexcept {
32819   std::pair<const char16_t*, char*> ret = sse_convert_utf16_to_utf8<endianness::BIG>(buf, len, utf8_output);
32822   if (ret.first != buf + len) {
32824                                         ret.first, len - (ret.first - buf), ret.second);
32831 simdutf_warn_unused result implementation::convert_utf16le_to_utf8_with_errors(const char16_t* buf, size_t len, char* utf8_output) const noexcept {
32833   std::pair<result, char*> ret = westmere::sse_convert_utf16_to_utf8_with_errors<endianness::LITTLE>(buf, len, utf8_output);
32835   if (ret.first.count != len) { // All good so far, but not finished
32837                                         buf + ret.first.count, len - ret.first.count, ret.second);
32849 simdutf_warn_unused result implementation::convert_utf16be_to_utf8_with_errors(const char16_t* buf, size_t len, char* utf8_output) const noexcept {
32851   std::pair<result, char*> ret = westmere::sse_convert_utf16_to_utf8_with_errors<endianness::BIG>(buf, len, utf8_output);
32853   if (ret.first.count != len) { // All good so far, but not finished
32855                                         buf + ret.first.count, len - ret.first.count, ret.second);
32867 simdutf_warn_unused size_t implementation::convert_valid_utf16le_to_utf8(const char16_t* buf, size_t len, char* utf8_output) const noexcept {
32868   return convert_utf16le_to_utf8(buf, len, utf8_output);
32871 simdutf_warn_unused size_t implementation::convert_valid_utf16be_to_utf8(const char16_t* buf, size_t len, char* utf8_output) const noexcept {
32872   return convert_utf16be_to_utf8(buf, len, utf8_output);
32875 simdutf_warn_unused size_t implementation::convert_utf32_to_latin1(const char32_t* buf, size_t len, char* latin1_output) const noexcept {
32876   std::pair<const char32_t*, char*> ret = sse_convert_utf32_to_latin1(buf, len, latin1_output);
32879   // if (ret.first != buf + len) {
32880   if (ret.first < buf + len) {
32882                                         ret.first, len - (ret.first - buf), ret.second);
32890 simdutf_warn_unused result implementation::convert_utf32_to_latin1_with_errors(const char32_t* buf, size_t len, char* latin1_output) const noexcept {
32892   std::pair<result, char*> ret = westmere::sse_convert_utf32_to_latin1_with_errors(buf, len, latin1_output);
32893   if (ret.first.count != len) {
32895                                         buf + ret.first.count, len - ret.first.count, ret.second);
32907 simdutf_warn_unused size_t implementation::convert_valid_utf32_to_latin1(const char32_t* buf, size_t len, char* latin1_output) const noexcept {
32909   return convert_utf32_to_latin1(buf,len,latin1_output);
32912 simdutf_warn_unused size_t implementation::convert_utf32_to_utf8(const char32_t* buf, size_t len, char* utf8_output) const noexcept {
32913   std::pair<const char32_t*, char*> ret = sse_convert_utf32_to_utf8(buf, len, utf8_output);
32916   if (ret.first != buf + len) {
32918                                         ret.first, len - (ret.first - buf), ret.second);
32925 simdutf_warn_unused result implementation::convert_utf32_to_utf8_with_errors(const char32_t* buf, size_t len, char* utf8_output) const noexcept {
32927   std::pair<result, char*> ret = westmere::sse_convert_utf32_to_utf8_with_errors(buf, len, utf8_output);
32928   if (ret.first.count != len) {
32930                                         buf + ret.first.count, len - ret.first.count, ret.second);
32942 simdutf_warn_unused size_t implementation::convert_utf16le_to_utf32(const char16_t* buf, size_t len, char32_t* utf32_output) const noexcept {
32943   std::pair<const char16_t*, char32_t*> ret = sse_convert_utf16_to_utf32<endianness::LITTLE>(buf, len, utf32_output);
32946   if (ret.first != buf + len) {
32948                                         ret.first, len - (ret.first - buf), ret.second);
32955 simdutf_warn_unused size_t implementation::convert_utf16be_to_utf32(const char16_t* buf, size_t len, char32_t* utf32_output) const noexcept {
32956   std::pair<const char16_t*, char32_t*> ret = sse_convert_utf16_to_utf32<endianness::BIG>(buf, len, utf32_output);
32959   if (ret.first != buf + len) {
32961                                         ret.first, len - (ret.first - buf), ret.second);
32968 simdutf_warn_unused result implementation::convert_utf16le_to_utf32_with_errors(const char16_t* buf, size_t len, char32_t* utf32_output) const noexcept {
32970   std::pair<result, char32_t*> ret = westmere::sse_convert_utf16_to_utf32_with_errors<endianness::LITTLE>(buf, len, utf32_output);
32972   if (ret.first.count != len) { // All good so far, but not finished
32974                                         buf + ret.first.count, len - ret.first.count, ret.second);
32986 simdutf_warn_unused result implementation::convert_utf16be_to_utf32_with_errors(const char16_t* buf, size_t len, char32_t* utf32_output) const noexcept {
32988   std::pair<result, char32_t*> ret = westmere::sse_convert_utf16_to_utf32_with_errors<endianness::BIG>(buf, len, utf32_output);
32990   if (ret.first.count != len) { // All good so far, but not finished
32992                                         buf + ret.first.count, len - ret.first.count, ret.second);
33004 simdutf_warn_unused size_t implementation::convert_valid_utf32_to_utf8(const char32_t* buf, size_t len, char* utf8_output) const noexcept {
33005   return convert_utf32_to_utf8(buf, len, utf8_output);
33008 simdutf_warn_unused size_t implementation::convert_utf32_to_utf16le(const char32_t* buf, size_t len, char16_t* utf16_output) const noexcept {
33009   std::pair<const char32_t*, char16_t*> ret = sse_convert_utf32_to_utf16<endianness::LITTLE>(buf, len, utf16_output);
33012   if (ret.first != buf + len) {
33014                                         ret.first, len - (ret.first - buf), ret.second);
33021 simdutf_warn_unused size_t implementation::convert_utf32_to_utf16be(const char32_t* buf, size_t len, char16_t* utf16_output) const noexcept {
33022   std::pair<const char32_t*, char16_t*> ret = sse_convert_utf32_to_utf16<endianness::BIG>(buf, len, utf16_output);
33025   if (ret.first != buf + len) {
33027                                         ret.first, len - (ret.first - buf), ret.second);
33034 simdutf_warn_unused result implementation::convert_utf32_to_utf16le_with_errors(const char32_t* buf, size_t len, char16_t* utf16_output) const noexcept {
33036   std::pair<result, char16_t*> ret = westmere::sse_convert_utf32_to_utf16_with_errors<endianness::LITTLE>(buf, len, utf16_output);
33037   if (ret.first.count != len) {
33039                                         buf + ret.first.count, len - ret.first.count, ret.second);
33051 simdutf_warn_unused result implementation::convert_utf32_to_utf16be_with_errors(const char32_t* buf, size_t len, char16_t* utf16_output) const noexcept {
33053   std::pair<result, char16_t*> ret = westmere::sse_convert_utf32_to_utf16_with_errors<endianness::BIG>(buf, len, utf16_output);
33054   if (ret.first.count != len) {
33056                                         buf + ret.first.count, len - ret.first.count, ret.second);
33068 simdutf_warn_unused size_t implementation::convert_valid_utf32_to_utf16le(const char32_t* buf, size_t len, char16_t* utf16_output) const noexcept {
33069   return convert_utf32_to_utf16le(buf, len, utf16_output);
33072 simdutf_warn_unused size_t implementation::convert_valid_utf32_to_utf16be(const char32_t* buf, size_t len, char16_t* utf16_output) const noexcept {
33073   return convert_utf32_to_utf16be(buf, len, utf16_output);
33076 simdutf_warn_unused size_t implementation::convert_valid_utf16le_to_utf32(const char16_t* buf, size_t len, char32_t* utf32_output) const noexcept {
33077   return convert_utf16le_to_utf32(buf, len, utf32_output);
33080 simdutf_warn_unused size_t implementation::convert_valid_utf16be_to_utf32(const char16_t* buf, size_t len, char32_t* utf32_output) const noexcept {
33081   return convert_utf16be_to_utf32(buf, len, utf32_output);
33100 simdutf_warn_unused size_t implementation::latin1_length_from_utf8(const char* buf, size_t len) const noexcept {
33101   return count_utf8(buf,len);
33128 simdutf_warn_unused size_t implementation::utf8_length_from_latin1(const char * input, size_t len) const noexcept {
33130   size_t answer = len / sizeof(__m128i) * sizeof(__m128i);
33133   while (i + sizeof(__m128i) <= len) {
33135     size_t iterations = (len - i) / sizeof(__m128i);
33172   return answer + scalar::latin1::utf8_length_from_latin1(reinterpret_cast<const char *>(str + i), len - i);

Indexes created Thu Nov 07 10:32:03 CST 2024