textcode 0.3.1

Text encoding/decoding library. Supports: UTF-8, ISO6937, ISO8859, GB2312
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

//! Simplified Chinese

use std::io::Write;

use crate::{
    ENCODE_FALLBACK,
    Textcode,
    data::{
        DECODE_MAP_GB2312,
        ENCODE_MAP_GB2312,
        HI_MAP_GB2312,
    },
    write_ascii,
    write_decode_fallback,
    write_utf8,
};

const LO_SIZE: usize = 0x7F - 0x21;

/// Simplified Chinese encoding.
pub struct Gb2312;

impl Textcode for Gb2312 {
    fn decode<W: Write, R: AsRef<[u8]>>(src: R, dst: &mut W) -> std::io::Result<usize> {
        let src = src.as_ref();
        let mut skip = 0;
        let size = src.len();
        let mut written = 0;

        while skip < size {
            let c = src[skip];

            if c <= 0x7F {
                written += write_ascii(dst, c)?;
                skip += 1;
                continue;
            }

            skip += 1;
            if skip >= size {
                written += write_decode_fallback(dst)?;
                break;
            }

            let hi = usize::from(c) & 0x7F;
            let lo = usize::from(src[skip]) & 0x7F;
            skip += 1;

            if lo < 0x21 || hi < 0x21 {
                written += write_decode_fallback(dst)?;
                continue;
            }

            let offset = (hi - 0x21) * LO_SIZE + (lo - 0x21);

            if offset >= DECODE_MAP_GB2312.len() {
                written += write_decode_fallback(dst)?;
                continue;
            }

            let u = DECODE_MAP_GB2312[offset] as u32;
            written += write_utf8(dst, u)?;
        }

        Ok(written)
    }

    fn encode<W: Write, R: AsRef<str>>(src: R, dst: &mut W) -> std::io::Result<usize> {
        let src = src.as_ref();
        let mut written = 0;

        for ch in src.chars() {
            let u = ch as u32;
            let mut buf = [0u8; 2];
            let n: usize;

            if u <= 0x7F {
                buf[0] = u as u8;
                n = 1;
            } else if u >= 0xA0 {
                let hi = (u >> 8) as usize;
                let lo = (u & 0xFF) as usize;

                let pos = HI_MAP_GB2312[hi] * 0x100 + lo;
                let code = ENCODE_MAP_GB2312[pos];

                if code != 0x0000 {
                    buf[0] = (code >> 8) as u8;
                    buf[1] = (code & 0xFF) as u8;
                    n = 2;
                } else {
                    buf[0] = ENCODE_FALLBACK;
                    n = 1;
                }
            } else {
                buf[0] = ENCODE_FALLBACK;
                n = 1;
            }

            dst.write_all(&buf[.. n])?;
            written += n;
        }

        Ok(written)
    }
}