1#[cfg(coverage)]
11use std::cell::Cell;
12
13use qubit_codec::CapacityError;
14use qubit_codec::TranscodeEncodeError;
15use qubit_codec::TranscodeStatus;
16use qubit_codec::Transcoder;
17use qubit_codec_text::Charset;
18use qubit_codec_text::CharsetCodec;
19use qubit_codec_text::CharsetEncodeError;
20use qubit_codec_text::CharsetEncodeErrorKind;
21use qubit_codec_text::CharsetEncodePolicy;
22use qubit_codec_text::CharsetEncoder;
23use qubit_codec_text::UnmappableAction;
24use qubit_utils::try_reserve_vec;
25
26const CHAR_CHUNK_CAPACITY: usize = 256;
27
28pub struct CharsetStringEncoder<C>
51where
52 C: CharsetCodec,
53{
54 encoder: CharsetEncoder<C>,
56}
57
58impl<C> CharsetStringEncoder<C>
59where
60 C: CharsetCodec,
61{
62 #[must_use]
78 #[inline]
79 pub fn new(codec: C) -> Self {
80 Self {
81 encoder: CharsetEncoder::new(codec),
82 }
83 }
84
85 pub fn with_policy(codec: C, policy: CharsetEncodePolicy) -> Result<Self, CharsetEncodeError> {
101 Ok(Self {
102 encoder: CharsetEncoder::with_policy(codec, policy)?,
103 })
104 }
105
106 #[must_use]
108 #[inline]
109 pub const fn unmappable_action(&self) -> UnmappableAction {
110 self.encoder.unmappable_action()
111 }
112
113 #[must_use]
115 #[inline]
116 pub const fn replacement(&self) -> char {
117 self.encoder.replacement()
118 }
119
120 #[must_use]
122 #[inline(always)]
123 pub const fn encoder(&self) -> &CharsetEncoder<C> {
124 &self.encoder
125 }
126
127 #[must_use]
129 #[inline(always)]
130 pub fn encoder_mut(&mut self) -> &mut CharsetEncoder<C> {
131 &mut self.encoder
132 }
133
134 #[must_use]
136 #[inline]
137 pub fn into_encoder(self) -> CharsetEncoder<C> {
138 self.encoder
139 }
140
141 #[doc(hidden)]
147 #[cfg(coverage)]
148 pub fn coverage_fail_next_reserve() {
149 COVERAGE_RESERVE_FAIL_AFTER.with(|state| state.set(0));
150 }
151
152 #[doc(hidden)]
159 #[cfg(coverage)]
160 pub fn coverage_fail_reserve_after(successful_attempts: usize) {
161 COVERAGE_RESERVE_FAIL_AFTER.with(|state| state.set(successful_attempts));
162 }
163
164 #[doc(hidden)]
170 #[cfg(coverage)]
171 pub fn coverage_fail_next_capacity_bound() {
172 COVERAGE_CAPACITY_FAIL_AFTER.with(|state| state.set(0));
173 }
174
175 #[doc(hidden)]
182 #[cfg(coverage)]
183 pub fn coverage_fail_capacity_bound_after(successful_attempts: usize) {
184 COVERAGE_CAPACITY_FAIL_AFTER.with(|state| state.set(successful_attempts));
185 }
186
187 #[doc(hidden)]
193 #[cfg(coverage)]
194 pub fn coverage_reset_reserve_hooks() {
195 COVERAGE_RESERVE_FAIL_AFTER.with(|state| state.set(usize::MAX));
196 COVERAGE_CAPACITY_FAIL_AFTER.with(|state| state.set(usize::MAX));
197 }
198
199 pub fn encode_str(&mut self, input: &str) -> Result<Vec<C::Unit>, CharsetEncodeError>
214 where
215 C::Unit: Default,
216 {
217 let charset = self.encoder.charset();
218 let mut output = Vec::new();
219 let reset_capacity = map_capacity_bound(self.encoder.max_reset_output_len(), charset)?;
220 ensure_owned_capacity(&mut output, 0, reset_capacity, charset)?;
221 let mut output_cursor = match self.encoder.reset(&mut output, 0) {
222 Ok(written) => written,
223 Err(error) => return Err(map_encode_error(charset, error)),
224 };
225
226 let mut chars = input.chars();
227 let mut input_offset = 0;
228 let mut chunk = ['\0'; CHAR_CHUNK_CAPACITY];
229 loop {
230 let chunk_len = fill_char_chunk(&mut chars, &mut chunk);
231 if chunk_len == 0 {
232 break;
233 }
234 let required = map_capacity_bound(self.encoder.max_transcode_output_len(chunk_len), charset)?;
235 ensure_owned_capacity(&mut output, output_cursor, required, charset)?;
236 let progress = match self
237 .encoder
238 .transcode(&chunk[..chunk_len], 0, &mut output, output_cursor)
239 {
240 Ok(progress) => progress,
241 Err(error) => {
242 return Err(map_chunk_encode_error(charset, error, input_offset));
243 }
244 };
245 output_cursor += progress.written();
246 input_offset += progress.read();
249 }
250
251 let finish_capacity = map_capacity_bound(self.encoder.max_finish_output_len(), charset)?;
252 ensure_owned_capacity(&mut output, output_cursor, finish_capacity, charset)?;
253 output_cursor += match self.encoder.finish(&mut output, output_cursor) {
254 Ok(written) => written,
255 Err(error) => return Err(map_encode_error(charset, error)),
256 };
257 output.truncate(output_cursor);
258 Ok(output)
259 }
260
261 pub fn encode_str_into(
283 &mut self,
284 input: &str,
285 output: &mut [C::Unit],
286 output_index: usize,
287 ) -> Result<usize, CharsetEncodeError> {
288 let charset = self.encoder.charset();
289 if output_index > output.len() {
290 return Err(CharsetEncodeError::new(
291 charset,
292 CharsetEncodeErrorKind::InvalidOutputIndex {
293 output_len: output.len(),
294 },
295 output_index,
296 ));
297 }
298 let mut output_cursor = output_index;
299 output_cursor += match self.encoder.reset(output, output_cursor) {
300 Ok(written) => written,
301 Err(error) => return Err(map_encode_error(charset, error)),
302 };
303
304 let mut chars = input.chars();
305 let mut input_offset = 0;
306 let mut chunk = ['\0'; CHAR_CHUNK_CAPACITY];
307 loop {
308 let chunk_len = fill_char_chunk(&mut chars, &mut chunk);
309 if chunk_len == 0 {
310 break;
311 }
312 map_capacity_bound(self.encoder.max_transcode_output_len(chunk_len), charset)?;
313 let progress = match self.encoder.transcode(&chunk[..chunk_len], 0, output, output_cursor) {
314 Ok(progress) => progress,
315 Err(error) => {
316 return Err(map_chunk_encode_error(charset, error, input_offset));
317 }
318 };
319 output_cursor += progress.written();
320 if let TranscodeStatus::NeedOutput { required } = progress.status() {
321 let available = output.len().saturating_sub(output_cursor);
322 return Err(CharsetEncodeError::new(
323 charset,
324 CharsetEncodeErrorKind::BufferTooSmall {
325 required: required.get(),
326 available,
327 },
328 output_cursor,
329 ));
330 }
331 input_offset += progress.read();
332 }
333
334 map_capacity_bound(self.encoder.max_finish_output_len(), charset)?;
335 output_cursor += match self.encoder.finish(output, output_cursor) {
336 Ok(written) => written,
337 Err(error) => return Err(map_encode_error(charset, error)),
338 };
339 Ok(output_cursor - output_index)
340 }
341}
342
343fn fill_char_chunk(chars: &mut impl Iterator<Item = char>, chunk: &mut [char; CHAR_CHUNK_CAPACITY]) -> usize {
354 let mut len = 0;
355 while len < chunk.len() {
356 let Some(ch) = chars.next() else {
357 break;
358 };
359 chunk[len] = ch;
360 len += 1;
361 }
362 len
363}
364
365fn ensure_owned_capacity<T>(
383 output: &mut Vec<T>,
384 output_index: usize,
385 required: usize,
386 charset: Charset,
387) -> Result<(), CharsetEncodeError>
388where
389 T: Default,
390{
391 let Some(required_len) = output_index.checked_add(required) else {
392 return Err(output_length_overflow(charset));
393 };
394 if required_len <= output.len() {
395 return Ok(());
396 }
397 let additional = required_len - output.len();
398 let reserve_failed = try_reserve_vec(output, additional).is_err();
399 #[cfg(coverage)]
400 let reserve_failed = reserve_failed || coverage_should_fail_reserve();
401 if reserve_failed {
402 return Err(output_length_overflow(charset));
403 }
404 output.resize_with(required_len, T::default);
405 Ok(())
406}
407
408fn map_capacity_bound(result: Result<usize, CapacityError>, charset: Charset) -> Result<usize, CharsetEncodeError> {
424 #[cfg(coverage)]
425 if coverage_should_fail_capacity_bound() {
426 return Err(output_length_overflow(charset));
427 }
428 match result {
429 Ok(capacity) => Ok(capacity),
430 Err(_) => Err(output_length_overflow(charset)),
431 }
432}
433
434fn map_encode_error(charset: Charset, error: TranscodeEncodeError<CharsetEncodeError, char>) -> CharsetEncodeError {
445 CharsetEncodeError::from_transcode_error(charset, error)
446}
447
448fn map_chunk_encode_error(
460 charset: Charset,
461 error: TranscodeEncodeError<CharsetEncodeError, char>,
462 input_offset: usize,
463) -> CharsetEncodeError {
464 let error = match error {
465 TranscodeEncodeError::Unencodable { input_index, value } => {
466 let input_index = input_offset.saturating_add(input_index);
467 return CharsetEncodeError::map_unencodable(charset, input_index, value);
468 }
469 error => map_encode_error(charset, error),
470 };
471 match error.kind() {
472 CharsetEncodeErrorKind::InvalidOutputIndex { .. }
473 | CharsetEncodeErrorKind::BufferTooSmall { .. }
474 | CharsetEncodeErrorKind::OutputLengthOverflow => error,
475 kind => CharsetEncodeError::new(charset, kind, input_offset.saturating_add(error.index())),
476 }
477}
478
479#[cfg(coverage)]
480thread_local! {
481 static COVERAGE_RESERVE_FAIL_AFTER: Cell<usize> = const { Cell::new(usize::MAX) };
482 static COVERAGE_CAPACITY_FAIL_AFTER: Cell<usize> = const { Cell::new(usize::MAX) };
483}
484
485#[cfg(coverage)]
487fn coverage_should_fail_capacity_bound() -> bool {
488 COVERAGE_CAPACITY_FAIL_AFTER.with(|state| {
489 let remaining = state.get();
490 if remaining == usize::MAX {
491 return false;
492 }
493 if remaining == 0 {
494 state.set(usize::MAX);
495 return true;
496 }
497 state.set(remaining - 1);
498 false
499 })
500}
501
502#[cfg(coverage)]
504fn coverage_should_fail_reserve() -> bool {
505 COVERAGE_RESERVE_FAIL_AFTER.with(|state| {
506 let remaining = state.get();
507 if remaining == usize::MAX {
508 return false;
509 }
510 if remaining == 0 {
511 state.set(usize::MAX);
512 return true;
513 }
514 state.set(remaining - 1);
515 false
516 })
517}
518
519#[inline]
529fn output_length_overflow(charset: Charset) -> CharsetEncodeError {
530 CharsetEncodeError::new(charset, CharsetEncodeErrorKind::OutputLengthOverflow, usize::MAX)
531}
532
533#[cfg(test)]
534mod tests {
535 use qubit_codec::TranscodeDomainError;
536 use qubit_codec::TranscodeEncodeError;
537 use qubit_codec::TranscodeFailure;
538 use qubit_codec_text::Charset;
539 use qubit_codec_text::CharsetEncodeError;
540 use qubit_codec_text::CharsetEncodeErrorKind;
541
542 use super::ensure_owned_capacity;
543 use super::map_chunk_encode_error;
544 use super::map_encode_error;
545
546 #[test]
547 fn test_charset_string_encoder_maps_transcode_failure() {
548 let error = map_encode_error(
549 Charset::UTF_8,
550 TranscodeEncodeError::Failure(TranscodeFailure::insufficient_output(3, 2, 1)),
551 );
552
553 assert_eq!(
554 CharsetEncodeErrorKind::BufferTooSmall {
555 required: 2,
556 available: 1,
557 },
558 error.kind(),
559 );
560 assert_eq!(3, error.index());
561 }
562
563 #[test]
564 fn test_charset_string_encoder_maps_unencodable_transcode_error() {
565 let error = map_encode_error(
566 Charset::UTF_8,
567 TranscodeEncodeError::Unencodable {
568 input_index: 3,
569 value: Some('中'),
570 },
571 );
572
573 assert_eq!(
574 CharsetEncodeErrorKind::UnmappableCharacter { value: '中' as u32 },
575 error.kind(),
576 );
577 assert_eq!(3, error.index());
578 }
579
580 #[test]
581 fn test_charset_string_encoder_maps_chunk_local_errors() {
582 let error = map_chunk_encode_error(
583 Charset::UTF_8,
584 TranscodeEncodeError::Unencodable {
585 input_index: 2,
586 value: Some('中'),
587 },
588 5,
589 );
590 assert_eq!(7, error.index());
591
592 let capacity_error = CharsetEncodeError::new(
593 Charset::UTF_8,
594 CharsetEncodeErrorKind::BufferTooSmall {
595 required: 2,
596 available: 1,
597 },
598 3,
599 );
600 let error = map_chunk_encode_error(
601 Charset::UTF_8,
602 TranscodeEncodeError::Domain(TranscodeDomainError::main(capacity_error, 0)),
603 5,
604 );
605 assert_eq!(capacity_error, error);
606 }
607
608 #[test]
609 fn test_charset_string_encoder_reports_owned_length_addition_overflow() {
610 let mut output = vec![7_u8];
611 let error = ensure_owned_capacity(&mut output, usize::MAX, 1, Charset::UTF_8)
612 .expect_err("owned output length addition should overflow");
613
614 assert_eq!(CharsetEncodeErrorKind::OutputLengthOverflow, error.kind());
615 assert_eq!(output, vec![7]);
616
617 ensure_owned_capacity(&mut output, 1, 0, Charset::UTF_8).expect("satisfied capacity should succeed");
618 assert_eq!(output, vec![7]);
619 ensure_owned_capacity(&mut output, 1, 1, Charset::UTF_8).expect("small owned capacity should be reservable");
620 assert_eq!(output, vec![7, 0]);
621 }
622}