1 // Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
11 use leb128
::{self, read_signed_leb128, write_signed_leb128}
;
13 use std
::io
::{self, Write}
;
16 // -----------------------------------------------------------------------------
18 // -----------------------------------------------------------------------------
20 pub type EncodeResult
= io
::Result
<()>;
22 pub struct Encoder
<'a
> {
23 pub cursor
: &'a
mut io
::Cursor
<Vec
<u8>>,
26 impl<'a
> Encoder
<'a
> {
27 pub fn new(cursor
: &'a
mut io
::Cursor
<Vec
<u8>>) -> Encoder
<'a
> {
28 Encoder { cursor: cursor }
31 pub fn emit_raw_bytes(&mut self, s
: &[u8]) -> EncodeResult
{
32 self.cursor
.write_all(s
)
37 macro_rules
! write_uleb128
{
38 ($enc
:expr
, $value
:expr
, $fun
:ident
) => {{
39 let pos
= $enc
.cursor
.position() as usize;
40 let bytes_written
= leb128
::$
fun($enc
.cursor
.get_mut(), pos
, $value
);
41 $enc
.cursor
.set_position((pos
+ bytes_written
) as u64);
46 macro_rules
! write_sleb128
{
47 ($enc
:expr
, $value
:expr
) => {{
48 let pos
= $enc
.cursor
.position() as usize;
49 let bytes_written
= write_signed_leb128($enc
.cursor
.get_mut(), pos
, $value
as i128
);
50 $enc
.cursor
.set_position((pos
+ bytes_written
) as u64);
55 impl<'a
> serialize
::Encoder
for Encoder
<'a
> {
56 type Error
= io
::Error
;
59 fn emit_nil(&mut self) -> EncodeResult
{
64 fn emit_usize(&mut self, v
: usize) -> EncodeResult
{
65 write_uleb128
!(self, v
, write_usize_leb128
)
69 fn emit_u128(&mut self, v
: u128
) -> EncodeResult
{
70 write_uleb128
!(self, v
, write_u128_leb128
)
74 fn emit_u64(&mut self, v
: u64) -> EncodeResult
{
75 write_uleb128
!(self, v
, write_u64_leb128
)
79 fn emit_u32(&mut self, v
: u32) -> EncodeResult
{
80 write_uleb128
!(self, v
, write_u32_leb128
)
84 fn emit_u16(&mut self, v
: u16) -> EncodeResult
{
85 write_uleb128
!(self, v
, write_u16_leb128
)
89 fn emit_u8(&mut self, v
: u8) -> EncodeResult
{
90 let pos
= self.cursor
.position() as usize;
91 leb128
::write_to_vec(self.cursor
.get_mut(), pos
, v
);
92 self.cursor
.set_position((pos
+ 1) as u64);
97 fn emit_isize(&mut self, v
: isize) -> EncodeResult
{
98 write_sleb128
!(self, v
)
102 fn emit_i128(&mut self, v
: i128
) -> EncodeResult
{
103 write_sleb128
!(self, v
)
107 fn emit_i64(&mut self, v
: i64) -> EncodeResult
{
108 write_sleb128
!(self, v
)
112 fn emit_i32(&mut self, v
: i32) -> EncodeResult
{
113 write_sleb128
!(self, v
)
117 fn emit_i16(&mut self, v
: i16) -> EncodeResult
{
118 write_sleb128
!(self, v
)
122 fn emit_i8(&mut self, v
: i8) -> EncodeResult
{
123 let as_u8
: u8 = unsafe { ::std::mem::transmute(v) }
;
128 fn emit_bool(&mut self, v
: bool
) -> EncodeResult
{
137 fn emit_f64(&mut self, v
: f64) -> EncodeResult
{
138 let as_u64
: u64 = unsafe { ::std::mem::transmute(v) }
;
139 self.emit_u64(as_u64
)
143 fn emit_f32(&mut self, v
: f32) -> EncodeResult
{
144 let as_u32
: u32 = unsafe { ::std::mem::transmute(v) }
;
145 self.emit_u32(as_u32
)
149 fn emit_char(&mut self, v
: char) -> EncodeResult
{
150 self.emit_u32(v
as u32)
154 fn emit_str(&mut self, v
: &str) -> EncodeResult
{
155 self.emit_usize(v
.len())?
;
156 let _
= self.cursor
.write_all(v
.as_bytes());
161 impl<'a
> Encoder
<'a
> {
163 pub fn position(&self) -> usize {
164 self.cursor
.position() as usize
168 // -----------------------------------------------------------------------------
170 // -----------------------------------------------------------------------------
172 pub struct Decoder
<'a
> {
177 impl<'a
> Decoder
<'a
> {
178 pub fn new(data
: &'a
[u8], position
: usize) -> Decoder
<'a
> {
186 pub fn position(&self) -> usize {
191 pub fn set_position(&mut self, pos
: usize) {
196 pub fn advance(&mut self, bytes
: usize) {
197 self.position
+= bytes
;
200 pub fn read_raw_bytes(&mut self, s
: &mut [u8]) -> Result
<(), String
> {
201 let start
= self.position
;
202 let end
= start
+ s
.len();
204 s
.copy_from_slice(&self.data
[start
..end
]);
212 macro_rules
! read_uleb128
{
213 ($dec
:expr
, $t
:ty
, $fun
:ident
) => ({
214 let (value
, bytes_read
) = leb128
::$
fun(&$dec
.data
[$dec
.position
..]);
215 $dec
.position
+= bytes_read
;
220 macro_rules
! read_sleb128
{
221 ($dec
:expr
, $t
:ty
) => ({
222 let (value
, bytes_read
) = read_signed_leb128($dec
.data
, $dec
.position
);
223 $dec
.position
+= bytes_read
;
229 impl<'a
> serialize
::Decoder
for Decoder
<'a
> {
233 fn read_nil(&mut self) -> Result
<(), Self::Error
> {
238 fn read_u128(&mut self) -> Result
<u128
, Self::Error
> {
239 read_uleb128
!(self, u128
, read_u128_leb128
)
243 fn read_u64(&mut self) -> Result
<u64, Self::Error
> {
244 read_uleb128
!(self, u64, read_u64_leb128
)
248 fn read_u32(&mut self) -> Result
<u32, Self::Error
> {
249 read_uleb128
!(self, u32, read_u32_leb128
)
253 fn read_u16(&mut self) -> Result
<u16, Self::Error
> {
254 read_uleb128
!(self, u16, read_u16_leb128
)
258 fn read_u8(&mut self) -> Result
<u8, Self::Error
> {
259 let value
= self.data
[self.position
];
265 fn read_usize(&mut self) -> Result
<usize, Self::Error
> {
266 read_uleb128
!(self, usize, read_usize_leb128
)
270 fn read_i128(&mut self) -> Result
<i128
, Self::Error
> {
271 read_sleb128
!(self, i128
)
275 fn read_i64(&mut self) -> Result
<i64, Self::Error
> {
276 read_sleb128
!(self, i64)
280 fn read_i32(&mut self) -> Result
<i32, Self::Error
> {
281 read_sleb128
!(self, i32)
285 fn read_i16(&mut self) -> Result
<i16, Self::Error
> {
286 read_sleb128
!(self, i16)
290 fn read_i8(&mut self) -> Result
<i8, Self::Error
> {
291 let as_u8
= self.data
[self.position
];
293 unsafe { Ok(::std::mem::transmute(as_u8)) }
297 fn read_isize(&mut self) -> Result
<isize, Self::Error
> {
298 read_sleb128
!(self, isize)
302 fn read_bool(&mut self) -> Result
<bool
, Self::Error
> {
303 let value
= self.read_u8()?
;
308 fn read_f64(&mut self) -> Result
<f64, Self::Error
> {
309 let bits
= self.read_u64()?
;
310 Ok(unsafe { ::std::mem::transmute(bits) }
)
314 fn read_f32(&mut self) -> Result
<f32, Self::Error
> {
315 let bits
= self.read_u32()?
;
316 Ok(unsafe { ::std::mem::transmute(bits) }
)
320 fn read_char(&mut self) -> Result
<char, Self::Error
> {
321 let bits
= self.read_u32()?
;
322 Ok(::std
::char::from_u32(bits
).unwrap())
326 fn read_str(&mut self) -> Result
<Cow
<str>, Self::Error
> {
327 let len
= self.read_usize()?
;
328 let s
= ::std
::str::from_utf8(&self.data
[self.position
..self.position
+ len
]).unwrap();
329 self.position
+= len
;
333 fn error(&mut self, err
: &str) -> Self::Error
{
341 use serialize
::{Encodable, Decodable}
;
344 use super::{Encoder, Decoder}
;
346 #[derive(PartialEq, Clone, Debug, RustcEncodable, RustcDecodable)]
370 fn check_round_trip
<T
: Encodable
+ Decodable
+ PartialEq
+ Debug
>(values
: Vec
<T
>) {
371 let mut cursor
= Cursor
::new(Vec
::new());
373 for value
in &values
{
374 let mut encoder
= Encoder
::new(&mut cursor
);
375 Encodable
::encode(&value
, &mut encoder
).unwrap();
378 let data
= cursor
.into_inner();
379 let mut decoder
= Decoder
::new(&data
[..], 0);
381 for value
in values
{
382 let decoded
= Decodable
::decode(&mut decoder
).unwrap();
383 assert_eq
!(value
, decoded
);
389 check_round_trip(vec
![(), (), (), ()]);
394 let mut vec
= vec
![];
395 for i
in ::std
::u8::MIN
..::std
::u8::MAX
{
398 check_round_trip(vec
);
403 for i
in ::std
::u16::MIN
..::std
::u16::MAX
{
404 check_round_trip(vec
![1, 2, 3, i
, i
, i
]);
410 check_round_trip(vec
![1, 2, 3, ::std
::u32::MIN
, 0, 1, ::std
::u32::MAX
, 2, 1]);
415 check_round_trip(vec
![1, 2, 3, ::std
::u64::MIN
, 0, 1, ::std
::u64::MAX
, 2, 1]);
420 check_round_trip(vec
![1, 2, 3, ::std
::usize::MIN
, 0, 1, ::std
::usize::MAX
, 2, 1]);
425 let mut vec
= vec
![];
426 for i
in ::std
::i8::MIN
..::std
::i8::MAX
{
429 check_round_trip(vec
);
434 for i
in ::std
::i16::MIN
..::std
::i16::MAX
{
435 check_round_trip(vec
![-1, 2, -3, i
, i
, i
, 2]);
441 check_round_trip(vec
![-1, 2, -3, ::std
::i32::MIN
, 0, 1, ::std
::i32::MAX
, 2, 1]);
446 check_round_trip(vec
![-1, 2, -3, ::std
::i64::MIN
, 0, 1, ::std
::i64::MAX
, 2, 1]);
451 check_round_trip(vec
![-1, 2, -3, ::std
::isize::MIN
, 0, 1, ::std
::isize::MAX
, 2, 1]);
456 check_round_trip(vec
![false, true, true, false, false]);
461 let mut vec
= vec
![];
463 vec
.push((i
as f32) / 3.0);
465 check_round_trip(vec
);
470 let mut vec
= vec
![];
472 vec
.push((i
as f64) / 3.0);
474 check_round_trip(vec
);
479 let vec
= vec
!['a'
, 'b'
, 'c'
, 'd'
, 'A'
, 'X'
, ' '
, '
#', 'Ö', 'Ä', 'µ', '€'];
480 check_round_trip(vec
);
485 let vec
= vec
!["abcbuÖeiovÄnameÜavmpßvmea€µsbpnvapeapmaebn".to_string(),
486 "abcbuÖganeiovÄnameÜavmpßvmea€µsbpnvapeapmaebn".to_string(),
487 "abcbuÖganeiovÄnameÜavmpßvmea€µsbpapmaebn".to_string(),
488 "abcbuÖganeiovÄnameÜavmpßvmeabpnvapeapmaebn".to_string(),
489 "abcbuÖganeiÄnameÜavmpßvmea€µsbpnvapeapmaebn".to_string(),
490 "abcbuÖganeiovÄnameÜavmpßvmea€µsbpmaebn".to_string(),
491 "abcbuÖganeiovÄnameÜavmpßvmea€µnvapeapmaebn".to_string()];
493 check_round_trip(vec
);
498 check_round_trip(vec
![Some(-1i8)]);
499 check_round_trip(vec
![Some(-2i16)]);
500 check_round_trip(vec
![Some(-3i32)]);
501 check_round_trip(vec
![Some(-4i64)]);
502 check_round_trip(vec
![Some(-5isize
)]);
504 let none_i8
: Option
<i8> = None
;
505 check_round_trip(vec
![none_i8
]);
507 let none_i16
: Option
<i16> = None
;
508 check_round_trip(vec
![none_i16
]);
510 let none_i32
: Option
<i32> = None
;
511 check_round_trip(vec
![none_i32
]);
513 let none_i64
: Option
<i64> = None
;
514 check_round_trip(vec
![none_i64
]);
516 let none_isize
: Option
<isize> = None
;
517 check_round_trip(vec
![none_isize
]);
522 check_round_trip(vec
![Struct
{
537 m
: "abc".to_string(),
544 check_round_trip(vec
![Struct
{
559 m
: "def".to_string(),
567 #[derive(PartialEq, Clone, Debug, RustcEncodable, RustcDecodable)]
570 Variant2(usize, f32),
580 check_round_trip(vec
![Enum
::Variant1
,
581 Enum
::Variant2(1, 2.5),
596 let mut vec
= vec
![];
597 for i
in -100i64..100i64 {
598 vec
.push(i
* 100000);
601 check_round_trip(vec
![vec
]);
606 use std
::collections
::HashMap
;
607 let mut map
= HashMap
::new();
608 for i
in -100i64..100i64 {
609 map
.insert(i
* 100000, i
* 10000);
612 check_round_trip(vec
![map
]);
617 check_round_trip(vec
![('x'
, (), false, 0.5f32)]);
618 check_round_trip(vec
![(9i8, 10u16, 1.5f64)]);
619 check_round_trip(vec
![(-12i16, 11u8, 12usize
)]);
620 check_round_trip(vec
![(1234567isize
, 100000000000000u64, 99999999999999i64)]);
621 check_round_trip(vec
![(String
::new(), "some string".to_string())]);