encoding_rs/
variant.rs

Help
1// Copyright Mozilla Foundation. See the COPYRIGHT
2// file at the top-level directory of this distribution.
3//
4// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
5// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
6// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
7// option. This file may not be copied, modified, or distributed
8// except according to those terms.
9
10// THIS IS A GENERATED FILE. PLEASE DO NOT EDIT.
11// Instead, please regenerate using generate-encoding-data.py
12
13//! This module provides enums that wrap the various decoders and encoders.
14//! The purpose is to make `Decoder` and `Encoder` `Sized` by writing the
15//! dispatch explicitly for a finite set of specialized decoders and encoders.
16//! Unfortunately, this means the compiler doesn't generate the dispatch code
17//! and it has to be written here instead.
18//!
19//! The purpose of making `Decoder` and `Encoder` `Sized` is to allow stack
20//! allocation in Rust code, including the convenience methods on `Encoding`.
21
22use super::*;
23use crate::big5::*;
24use crate::euc_jp::*;
25use crate::euc_kr::*;
26use crate::gb18030::*;
27use crate::iso_2022_jp::*;
28use crate::replacement::*;
29use crate::shift_jis::*;
30use crate::single_byte::*;
31use crate::utf_16::*;
32use crate::utf_8::*;
33use crate::x_user_defined::*;
34
35pub enum VariantDecoder {
36    SingleByte(SingleByteDecoder),
37    Utf8(Utf8Decoder),
38    Gb18030(Gb18030Decoder),
39    Big5(Big5Decoder),
40    EucJp(EucJpDecoder),
41    Iso2022Jp(Iso2022JpDecoder),
42    ShiftJis(ShiftJisDecoder),
43    EucKr(EucKrDecoder),
44    Replacement(ReplacementDecoder),
45    UserDefined(UserDefinedDecoder),
46    Utf16(Utf16Decoder),
47}
48
49impl VariantDecoder {
50    pub fn max_utf16_buffer_length(&self, byte_length: usize) -> Option<usize> {
51        match *self {
52            VariantDecoder::SingleByte(ref v) => v.max_utf16_buffer_length(byte_length),
53            VariantDecoder::Utf8(ref v) => v.max_utf16_buffer_length(byte_length),
54            VariantDecoder::Gb18030(ref v) => v.max_utf16_buffer_length(byte_length),
55            VariantDecoder::Big5(ref v) => v.max_utf16_buffer_length(byte_length),
56            VariantDecoder::EucJp(ref v) => v.max_utf16_buffer_length(byte_length),
57            VariantDecoder::Iso2022Jp(ref v) => v.max_utf16_buffer_length(byte_length),
58            VariantDecoder::ShiftJis(ref v) => v.max_utf16_buffer_length(byte_length),
59            VariantDecoder::EucKr(ref v) => v.max_utf16_buffer_length(byte_length),
60            VariantDecoder::Replacement(ref v) => v.max_utf16_buffer_length(byte_length),
61            VariantDecoder::UserDefined(ref v) => v.max_utf16_buffer_length(byte_length),
62            VariantDecoder::Utf16(ref v) => v.max_utf16_buffer_length(byte_length),
63        }
64    }
65
66    pub fn max_utf8_buffer_length_without_replacement(&self, byte_length: usize) -> Option<usize> {
67        match *self {
68            VariantDecoder::SingleByte(ref v) => {
69                v.max_utf8_buffer_length_without_replacement(byte_length)
70            }
71            VariantDecoder::Utf8(ref v) => {
72                v.max_utf8_buffer_length_without_replacement(byte_length)
73            }
74            VariantDecoder::Gb18030(ref v) => {
75                v.max_utf8_buffer_length_without_replacement(byte_length)
76            }
77            VariantDecoder::Big5(ref v) => {
78                v.max_utf8_buffer_length_without_replacement(byte_length)
79            }
80            VariantDecoder::EucJp(ref v) => {
81                v.max_utf8_buffer_length_without_replacement(byte_length)
82            }
83            VariantDecoder::Iso2022Jp(ref v) => {
84                v.max_utf8_buffer_length_without_replacement(byte_length)
85            }
86            VariantDecoder::ShiftJis(ref v) => {
87                v.max_utf8_buffer_length_without_replacement(byte_length)
88            }
89            VariantDecoder::EucKr(ref v) => {
90                v.max_utf8_buffer_length_without_replacement(byte_length)
91            }
92            VariantDecoder::Replacement(ref v) => {
93                v.max_utf8_buffer_length_without_replacement(byte_length)
94            }
95            VariantDecoder::UserDefined(ref v) => {
96                v.max_utf8_buffer_length_without_replacement(byte_length)
97            }
98            VariantDecoder::Utf16(ref v) => {
99                v.max_utf8_buffer_length_without_replacement(byte_length)
100            }
101        }
102    }
103
104    pub fn max_utf8_buffer_length(&self, byte_length: usize) -> Option<usize> {
105        match *self {
106            VariantDecoder::SingleByte(ref v) => v.max_utf8_buffer_length(byte_length),
107            VariantDecoder::Utf8(ref v) => v.max_utf8_buffer_length(byte_length),
108            VariantDecoder::Gb18030(ref v) => v.max_utf8_buffer_length(byte_length),
109            VariantDecoder::Big5(ref v) => v.max_utf8_buffer_length(byte_length),
110            VariantDecoder::EucJp(ref v) => v.max_utf8_buffer_length(byte_length),
111            VariantDecoder::Iso2022Jp(ref v) => v.max_utf8_buffer_length(byte_length),
112            VariantDecoder::ShiftJis(ref v) => v.max_utf8_buffer_length(byte_length),
113            VariantDecoder::EucKr(ref v) => v.max_utf8_buffer_length(byte_length),
114            VariantDecoder::Replacement(ref v) => v.max_utf8_buffer_length(byte_length),
115            VariantDecoder::UserDefined(ref v) => v.max_utf8_buffer_length(byte_length),
116            VariantDecoder::Utf16(ref v) => v.max_utf8_buffer_length(byte_length),
117        }
118    }
119
120    pub fn decode_to_utf16_raw(
121        &mut self,
122        src: &[u8],
123        dst: &mut [u16],
124        last: bool,
125    ) -> (DecoderResult, usize, usize) {
126        match *self {
127            VariantDecoder::SingleByte(ref mut v) => v.decode_to_utf16_raw(src, dst, last),
128            VariantDecoder::Utf8(ref mut v) => v.decode_to_utf16_raw(src, dst, last),
129            VariantDecoder::Gb18030(ref mut v) => v.decode_to_utf16_raw(src, dst, last),
130            VariantDecoder::Big5(ref mut v) => v.decode_to_utf16_raw(src, dst, last),
131            VariantDecoder::EucJp(ref mut v) => v.decode_to_utf16_raw(src, dst, last),
132            VariantDecoder::Iso2022Jp(ref mut v) => v.decode_to_utf16_raw(src, dst, last),
133            VariantDecoder::ShiftJis(ref mut v) => v.decode_to_utf16_raw(src, dst, last),
134            VariantDecoder::EucKr(ref mut v) => v.decode_to_utf16_raw(src, dst, last),
135            VariantDecoder::Replacement(ref mut v) => v.decode_to_utf16_raw(src, dst, last),
136            VariantDecoder::UserDefined(ref mut v) => v.decode_to_utf16_raw(src, dst, last),
137            VariantDecoder::Utf16(ref mut v) => v.decode_to_utf16_raw(src, dst, last),
138        }
139    }
140
141    pub fn decode_to_utf8_raw(
142        &mut self,
143        src: &[u8],
144        dst: &mut [u8],
145        last: bool,
146    ) -> (DecoderResult, usize, usize) {
147        match *self {
148            VariantDecoder::SingleByte(ref mut v) => v.decode_to_utf8_raw(src, dst, last),
149            VariantDecoder::Utf8(ref mut v) => v.decode_to_utf8_raw(src, dst, last),
150            VariantDecoder::Gb18030(ref mut v) => v.decode_to_utf8_raw(src, dst, last),
151            VariantDecoder::Big5(ref mut v) => v.decode_to_utf8_raw(src, dst, last),
152            VariantDecoder::EucJp(ref mut v) => v.decode_to_utf8_raw(src, dst, last),
153            VariantDecoder::Iso2022Jp(ref mut v) => v.decode_to_utf8_raw(src, dst, last),
154            VariantDecoder::ShiftJis(ref mut v) => v.decode_to_utf8_raw(src, dst, last),
155            VariantDecoder::EucKr(ref mut v) => v.decode_to_utf8_raw(src, dst, last),
156            VariantDecoder::Replacement(ref mut v) => v.decode_to_utf8_raw(src, dst, last),
157            VariantDecoder::UserDefined(ref mut v) => v.decode_to_utf8_raw(src, dst, last),
158            VariantDecoder::Utf16(ref mut v) => v.decode_to_utf8_raw(src, dst, last),
159        }
160    }
161
162    pub fn latin1_byte_compatible_up_to(&self, buffer: &[u8]) -> Option<usize> {
163        match *self {
164            VariantDecoder::SingleByte(ref v) => {
165                return Some(v.latin1_byte_compatible_up_to(buffer));
166            }
167            VariantDecoder::Utf8(ref v) => {
168                if !v.in_neutral_state() {
169                    return None;
170                }
171            }
172            VariantDecoder::Gb18030(ref v) => {
173                if !v.in_neutral_state() {
174                    return None;
175                }
176            }
177            VariantDecoder::Big5(ref v) => {
178                if !v.in_neutral_state() {
179                    return None;
180                }
181            }
182            VariantDecoder::EucJp(ref v) => {
183                if !v.in_neutral_state() {
184                    return None;
185                }
186            }
187            VariantDecoder::Iso2022Jp(ref v) => {
188                if v.in_neutral_state() {
189                    return Some(Encoding::iso_2022_jp_ascii_valid_up_to(buffer));
190                }
191                return None;
192            }
193            VariantDecoder::ShiftJis(ref v) => {
194                if !v.in_neutral_state() {
195                    return None;
196                }
197            }
198            VariantDecoder::EucKr(ref v) => {
199                if !v.in_neutral_state() {
200                    return None;
201                }
202            }
203            VariantDecoder::UserDefined(_) => {}
204            VariantDecoder::Replacement(_) | VariantDecoder::Utf16(_) => {
205                return None;
206            }
207        };
208        Some(Encoding::ascii_valid_up_to(buffer))
209    }
210}
211
212pub enum VariantEncoder {
213    SingleByte(SingleByteEncoder),
214    Utf8(Utf8Encoder),
215    Gb18030(Gb18030Encoder),
216    Big5(Big5Encoder),
217    EucJp(EucJpEncoder),
218    Iso2022Jp(Iso2022JpEncoder),
219    ShiftJis(ShiftJisEncoder),
220    EucKr(EucKrEncoder),
221    UserDefined(UserDefinedEncoder),
222}
223
224impl VariantEncoder {
225    pub fn has_pending_state(&self) -> bool {
226        match *self {
227            VariantEncoder::Iso2022Jp(ref v) => v.has_pending_state(),
228            _ => false,
229        }
230    }
231    pub fn max_buffer_length_from_utf16_without_replacement(
232        &self,
233        u16_length: usize,
234    ) -> Option<usize> {
235        match *self {
236            VariantEncoder::SingleByte(ref v) => {
237                v.max_buffer_length_from_utf16_without_replacement(u16_length)
238            }
239            VariantEncoder::Utf8(ref v) => {
240                v.max_buffer_length_from_utf16_without_replacement(u16_length)
241            }
242            VariantEncoder::Gb18030(ref v) => {
243                v.max_buffer_length_from_utf16_without_replacement(u16_length)
244            }
245            VariantEncoder::Big5(ref v) => {
246                v.max_buffer_length_from_utf16_without_replacement(u16_length)
247            }
248            VariantEncoder::EucJp(ref v) => {
249                v.max_buffer_length_from_utf16_without_replacement(u16_length)
250            }
251            VariantEncoder::Iso2022Jp(ref v) => {
252                v.max_buffer_length_from_utf16_without_replacement(u16_length)
253            }
254            VariantEncoder::ShiftJis(ref v) => {
255                v.max_buffer_length_from_utf16_without_replacement(u16_length)
256            }
257            VariantEncoder::EucKr(ref v) => {
258                v.max_buffer_length_from_utf16_without_replacement(u16_length)
259            }
260            VariantEncoder::UserDefined(ref v) => {
261                v.max_buffer_length_from_utf16_without_replacement(u16_length)
262            }
263        }
264    }
265
266    pub fn max_buffer_length_from_utf8_without_replacement(
267        &self,
268        byte_length: usize,
269    ) -> Option<usize> {
270        match *self {
271            VariantEncoder::SingleByte(ref v) => {
272                v.max_buffer_length_from_utf8_without_replacement(byte_length)
273            }
274            VariantEncoder::Utf8(ref v) => {
275                v.max_buffer_length_from_utf8_without_replacement(byte_length)
276            }
277            VariantEncoder::Gb18030(ref v) => {
278                v.max_buffer_length_from_utf8_without_replacement(byte_length)
279            }
280            VariantEncoder::Big5(ref v) => {
281                v.max_buffer_length_from_utf8_without_replacement(byte_length)
282            }
283            VariantEncoder::EucJp(ref v) => {
284                v.max_buffer_length_from_utf8_without_replacement(byte_length)
285            }
286            VariantEncoder::Iso2022Jp(ref v) => {
287                v.max_buffer_length_from_utf8_without_replacement(byte_length)
288            }
289            VariantEncoder::ShiftJis(ref v) => {
290                v.max_buffer_length_from_utf8_without_replacement(byte_length)
291            }
292            VariantEncoder::EucKr(ref v) => {
293                v.max_buffer_length_from_utf8_without_replacement(byte_length)
294            }
295            VariantEncoder::UserDefined(ref v) => {
296                v.max_buffer_length_from_utf8_without_replacement(byte_length)
297            }
298        }
299    }
300
301    pub fn encode_from_utf16_raw(
302        &mut self,
303        src: &[u16],
304        dst: &mut [u8],
305        last: bool,
306    ) -> (EncoderResult, usize, usize) {
307        match *self {
308            VariantEncoder::SingleByte(ref mut v) => v.encode_from_utf16_raw(src, dst, last),
309            VariantEncoder::Utf8(ref mut v) => v.encode_from_utf16_raw(src, dst, last),
310            VariantEncoder::Gb18030(ref mut v) => v.encode_from_utf16_raw(src, dst, last),
311            VariantEncoder::Big5(ref mut v) => v.encode_from_utf16_raw(src, dst, last),
312            VariantEncoder::EucJp(ref mut v) => v.encode_from_utf16_raw(src, dst, last),
313            VariantEncoder::Iso2022Jp(ref mut v) => v.encode_from_utf16_raw(src, dst, last),
314            VariantEncoder::ShiftJis(ref mut v) => v.encode_from_utf16_raw(src, dst, last),
315            VariantEncoder::EucKr(ref mut v) => v.encode_from_utf16_raw(src, dst, last),
316            VariantEncoder::UserDefined(ref mut v) => v.encode_from_utf16_raw(src, dst, last),
317        }
318    }
319
320    pub fn encode_from_utf8_raw(
321        &mut self,
322        src: &str,
323        dst: &mut [u8],
324        last: bool,
325    ) -> (EncoderResult, usize, usize) {
326        match *self {
327            VariantEncoder::SingleByte(ref mut v) => v.encode_from_utf8_raw(src, dst, last),
328            VariantEncoder::Utf8(ref mut v) => v.encode_from_utf8_raw(src, dst, last),
329            VariantEncoder::Gb18030(ref mut v) => v.encode_from_utf8_raw(src, dst, last),
330            VariantEncoder::Big5(ref mut v) => v.encode_from_utf8_raw(src, dst, last),
331            VariantEncoder::EucJp(ref mut v) => v.encode_from_utf8_raw(src, dst, last),
332            VariantEncoder::Iso2022Jp(ref mut v) => v.encode_from_utf8_raw(src, dst, last),
333            VariantEncoder::ShiftJis(ref mut v) => v.encode_from_utf8_raw(src, dst, last),
334            VariantEncoder::EucKr(ref mut v) => v.encode_from_utf8_raw(src, dst, last),
335            VariantEncoder::UserDefined(ref mut v) => v.encode_from_utf8_raw(src, dst, last),
336        }
337    }
338}
339
340pub enum VariantEncoding {
341    SingleByte(&'static [u16; 128], u16, u8, u8),
342    Utf8,
343    Gbk,
344    Gb18030,
345    Big5,
346    EucJp,
347    Iso2022Jp,
348    ShiftJis,
349    EucKr,
350    Replacement,
351    Utf16Be,
352    Utf16Le,
353    UserDefined,
354}
355
356impl VariantEncoding {
357    pub fn new_variant_decoder(&self) -> VariantDecoder {
358        match *self {
359            VariantEncoding::SingleByte(table, _, _, _) => SingleByteDecoder::new(table),
360            VariantEncoding::Utf8 => Utf8Decoder::new(),
361            VariantEncoding::Gbk | VariantEncoding::Gb18030 => Gb18030Decoder::new(),
362            VariantEncoding::Big5 => Big5Decoder::new(),
363            VariantEncoding::EucJp => EucJpDecoder::new(),
364            VariantEncoding::Iso2022Jp => Iso2022JpDecoder::new(),
365            VariantEncoding::ShiftJis => ShiftJisDecoder::new(),
366            VariantEncoding::EucKr => EucKrDecoder::new(),
367            VariantEncoding::Replacement => ReplacementDecoder::new(),
368            VariantEncoding::UserDefined => UserDefinedDecoder::new(),
369            VariantEncoding::Utf16Be => Utf16Decoder::new(true),
370            VariantEncoding::Utf16Le => Utf16Decoder::new(false),
371        }
372    }
373
374    pub fn new_encoder(&self, encoding: &'static Encoding) -> Encoder {
375        match *self {
376            VariantEncoding::SingleByte(table, run_bmp_offset, run_byte_offset, run_length) => {
377                SingleByteEncoder::new(encoding, table, run_bmp_offset, run_byte_offset, run_length)
378            }
379            VariantEncoding::Utf8 => Utf8Encoder::new(encoding),
380            VariantEncoding::Gbk => Gb18030Encoder::new(encoding, false),
381            VariantEncoding::Gb18030 => Gb18030Encoder::new(encoding, true),
382            VariantEncoding::Big5 => Big5Encoder::new(encoding),
383            VariantEncoding::EucJp => EucJpEncoder::new(encoding),
384            VariantEncoding::Iso2022Jp => Iso2022JpEncoder::new(encoding),
385            VariantEncoding::ShiftJis => ShiftJisEncoder::new(encoding),
386            VariantEncoding::EucKr => EucKrEncoder::new(encoding),
387            VariantEncoding::UserDefined => UserDefinedEncoder::new(encoding),
388            VariantEncoding::Utf16Be | VariantEncoding::Replacement | VariantEncoding::Utf16Le => {
389                unreachable!()
390            }
391        }
392    }
393
394    pub fn is_single_byte(&self) -> bool {
395        match *self {
396            VariantEncoding::SingleByte(_, _, _, _) | VariantEncoding::UserDefined => true,
397            _ => false,
398        }
399    }
400}
encoding_rs/variant.rs

encoding_rs/
variant.rs
