qubit-codec-text 0.1.0

Buffer-oriented text encoding and decoding utilities 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

use qubit_codec_text::prelude::{
    Ascii,
    BufferedTranscoder,
    ByteOrder,
    Charset,
    CharsetDecoder,
    CharsetEncoder,
    Codec,
    TranscodeStatus,
    Unicode,
    UnicodeBom,
    Utf8,
    Utf8Codec,
    Utf16,
    Utf16ByteCodec,
    Utf32,
    Utf32ByteCodec,
};

#[test]
fn test_prelude_reexports_common_types() {
    assert!(Ascii::is_ascii_char('A'));
    assert_eq!(Some(3), Utf8::byte_len_from_leading_byte(0xe4));
    assert_eq!(2, Utf16::unit_len('😀'));
    assert!(Utf32::is_valid_unit('中' as u32));
    assert!(Unicode::is_scalar_value('中' as u32));
    assert_eq!(
        Some(ByteOrder::LittleEndian),
        Utf16::detect_bom(&[0xff, 0xfe])
    );
    assert_eq!(
        Some(UnicodeBom::Utf8),
        UnicodeBom::detect(&[0xef, 0xbb, 0xbf])
    );

    let utf8 = Utf8Codec;
    assert_eq!(Charset::UTF_8, utf8.charset());
    assert_eq!(4, utf8.max_units_per_value().get());
    let (decoded, consumed) = unsafe {
        utf8.decode_unchecked("A".as_bytes(), 0)
            .expect("UTF-8 prefix")
    };
    assert_eq!('A', decoded);
    assert_eq!(1, consumed.get());
    let mut decoder = CharsetDecoder::new(utf8);
    let mut chars = ['\0'; 1];
    let progress = decoder
        .transcode("A".as_bytes(), 0, &mut chars, 0)
        .expect("policy decoder");
    assert_eq!(TranscodeStatus::Complete, progress.status());
    assert_eq!('A', chars[0]);

    let utf16 = Utf16ByteCodec::new(ByteOrder::BigEndian);
    assert_eq!(Charset::UTF_16BE, utf16.charset());

    let utf32 = Utf32ByteCodec::new(ByteOrder::LittleEndian);
    assert_eq!(Charset::UTF_32LE, utf32.charset());
    let mut encoder = CharsetEncoder::new(utf32);
    let mut output = [0_u8; 4];
    let progress = encoder
        .transcode(&['A'], 0, &mut output, 0)
        .expect("policy encoder");
    assert_eq!(TranscodeStatus::Complete, progress.status());
}