qubit-codec 0.5.0

Core codec traits and buffer conversion primitives for Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

/*******************************************************************************
 *
 *    Copyright (c) 2026 Haixing Hu.
 *
 *    SPDX-License-Identifier: Apache-2.0
 *
 *    Licensed under the Apache License, Version 2.0.
 *
 ******************************************************************************/
//! Tests for semantic buffered transcoder marker traits.

use qubit_codec::{
    BufferedConverter,
    BufferedDecoder,
    BufferedEncoder,
    BufferedTranscoder,
    CapacityError,
    TranscodeProgress,
};

#[derive(Default)]
struct CharToByte;

impl BufferedTranscoder<char, u8> for CharToByte {
    type Error = core::convert::Infallible;

    fn max_output_len(&self, input_len: usize) -> Result<usize, CapacityError> {
        Ok(input_len)
    }

    fn transcode(
        &mut self,
        input: &[char],
        input_index: usize,
        output: &mut [u8],
        output_index: usize,
    ) -> Result<TranscodeProgress, Self::Error> {
        let readable = input.len().saturating_sub(input_index);
        let writable = output.len().saturating_sub(output_index);
        let count = readable.min(writable);
        for offset in 0..count {
            output[output_index + offset] = input[input_index + offset] as u8;
        }
        Ok(TranscodeProgress::complete(count, count))
    }
}

impl BufferedEncoder<char, u8> for CharToByte {}

#[derive(Default)]
struct ByteToChar;

impl BufferedTranscoder<u8, char> for ByteToChar {
    type Error = core::convert::Infallible;

    fn max_output_len(&self, input_len: usize) -> Result<usize, CapacityError> {
        Ok(input_len)
    }

    fn transcode(
        &mut self,
        input: &[u8],
        input_index: usize,
        output: &mut [char],
        output_index: usize,
    ) -> Result<TranscodeProgress, Self::Error> {
        let readable = input.len().saturating_sub(input_index);
        let writable = output.len().saturating_sub(output_index);
        let count = readable.min(writable);
        for offset in 0..count {
            output[output_index + offset] = input[input_index + offset] as char;
        }
        Ok(TranscodeProgress::complete(count, count))
    }
}

impl BufferedDecoder<u8, char> for ByteToChar {}

#[derive(Default)]
struct ByteToWord;

impl BufferedTranscoder<u8, u16> for ByteToWord {
    type Error = core::convert::Infallible;

    fn max_output_len(&self, input_len: usize) -> Result<usize, CapacityError> {
        Ok(input_len)
    }

    fn transcode(
        &mut self,
        input: &[u8],
        input_index: usize,
        output: &mut [u16],
        output_index: usize,
    ) -> Result<TranscodeProgress, Self::Error> {
        let readable = input.len().saturating_sub(input_index);
        let writable = output.len().saturating_sub(output_index);
        let count = readable.min(writable);
        for offset in 0..count {
            output[output_index + offset] = input[input_index + offset] as u16;
        }
        Ok(TranscodeProgress::complete(count, count))
    }
}

impl BufferedConverter<u8, u16> for ByteToWord {}

#[test]
fn test_buffered_encoder_is_a_semantic_transcoder_bound() {
    fn assert_encoder<T: BufferedEncoder<char, u8>>() {}

    assert_encoder::<CharToByte>();
}

#[test]
fn test_buffered_decoder_is_a_semantic_transcoder_bound() {
    fn assert_decoder<T: BufferedDecoder<u8, char>>() {}

    assert_decoder::<ByteToChar>();
}

#[test]
fn test_buffered_converter_is_a_semantic_transcoder_bound() {
    fn assert_converter<T: BufferedConverter<u8, u16>>() {}

    assert_converter::<ByteToWord>();
}