1 // Copyright 2012 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 //! Support code for encoding and decoding types.
14 Core encoding and decoding interfaces.
17 #[forbid(non_camel_case_types)];
19 use core::hashmap::{HashMap, HashSet};
20 use core::trie::{TrieMap, TrieSet};
26 use treemap::{TreeMap, TreeSet};
31 fn emit_uint(&self, v: uint);
32 fn emit_u64(&self, v: u64);
33 fn emit_u32(&self, v: u32);
34 fn emit_u16(&self, v: u16);
35 fn emit_u8(&self, v: u8);
36 fn emit_int(&self, v: int);
37 fn emit_i64(&self, v: i64);
38 fn emit_i32(&self, v: i32);
39 fn emit_i16(&self, v: i16);
40 fn emit_i8(&self, v: i8);
41 fn emit_bool(&self, v: bool);
42 fn emit_float(&self, v: float);
43 fn emit_f64(&self, v: f64);
44 fn emit_f32(&self, v: f32);
45 fn emit_char(&self, v: char);
46 fn emit_str(&self, v: &str);
49 fn emit_enum(&self, name: &str, f: &fn());
51 fn emit_enum_variant(&self, v_name: &str, v_id: uint, len: uint, f: &fn());
52 fn emit_enum_variant_arg(&self, a_idx: uint, f: &fn());
54 fn emit_enum_struct_variant(&self, v_name: &str, v_id: uint, len: uint, f: &fn());
55 fn emit_enum_struct_variant_field(&self, f_name: &str, f_idx: uint, f: &fn());
57 fn emit_struct(&self, name: &str, len: uint, f: &fn());
59 fn emit_field(&self, f_name: &str, f_idx: uint, f: &fn());
63 fn emit_struct_field(&self, f_name: &str, f_idx: uint, f: &fn());
65 fn emit_tuple(&self, len: uint, f: &fn());
66 fn emit_tuple_arg(&self, idx: uint, f: &fn());
68 fn emit_tuple_struct(&self, name: &str, len: uint, f: &fn());
69 fn emit_tuple_struct_arg(&self, f_idx: uint, f: &fn());
72 fn emit_option(&self, f: &fn());
73 fn emit_option_none(&self);
74 fn emit_option_some(&self, f: &fn());
76 fn emit_seq(&self, len: uint, f: &fn());
77 fn emit_seq_elt(&self, idx: uint, f: &fn());
79 fn emit_map(&self, len: uint, f: &fn());
80 fn emit_map_elt_key(&self, idx: uint, f: &fn());
81 fn emit_map_elt_val(&self, idx: uint, f: &fn());
86 fn read_nil(&self) -> ();
87 fn read_uint(&self) -> uint;
88 fn read_u64(&self) -> u64;
89 fn read_u32(&self) -> u32;
90 fn read_u16(&self) -> u16;
91 fn read_u8(&self) -> u8;
92 fn read_int(&self) -> int;
93 fn read_i64(&self) -> i64;
94 fn read_i32(&self) -> i32;
95 fn read_i16(&self) -> i16;
96 fn read_i8(&self) -> i8;
97 fn read_bool(&self) -> bool;
98 fn read_f64(&self) -> f64;
99 fn read_f32(&self) -> f32;
100 fn read_float(&self) -> float;
101 fn read_char(&self) -> char;
102 fn read_str(&self) -> ~str;
105 fn read_enum<T>(&self, name: &str, f: &fn() -> T) -> T;
107 fn read_enum_variant<T>(&self, names: &[&str], f: &fn(uint) -> T) -> T;
108 fn read_enum_variant_arg<T>(&self, a_idx: uint, f: &fn() -> T) -> T;
110 fn read_enum_struct_variant<T>(&self, names: &[&str], f: &fn(uint) -> T) -> T;
111 fn read_enum_struct_variant_field<T>(&self, &f_name: &str, f_idx: uint, f: &fn() -> T) -> T;
113 fn read_struct<T>(&self, s_name: &str, len: uint, f: &fn() -> T) -> T;
115 fn read_field<T>(&self, f_name: &str, f_idx: uint, f: &fn() -> T) -> T;
119 fn read_struct_field<T>(&self, f_name: &str, f_idx: uint, f: &fn() -> T) -> T;
121 fn read_tuple<T>(&self, f: &fn(uint) -> T) -> T;
122 fn read_tuple_arg<T>(&self, a_idx: uint, f: &fn() -> T) -> T;
124 fn read_tuple_struct<T>(&self, s_name: &str, f: &fn(uint) -> T) -> T;
125 fn read_tuple_struct_arg<T>(&self, a_idx: uint, f: &fn() -> T) -> T;
127 // Specialized types:
128 fn read_option<T>(&self, f: &fn(bool) -> T) -> T;
130 fn read_seq<T>(&self, f: &fn(uint) -> T) -> T;
131 fn read_seq_elt<T>(&self, idx: uint, f: &fn() -> T) -> T;
133 fn read_map<T>(&self, f: &fn(uint) -> T) -> T;
134 fn read_map_elt_key<T>(&self, idx: uint, f: &fn() -> T) -> T;
135 fn read_map_elt_val<T>(&self, idx: uint, f: &fn() -> T) -> T;
138 pub trait Encodable<S:Encoder> {
139 fn encode(&self, s: &S);
142 pub trait Decodable<D:Decoder> {
143 fn decode(d: &D) -> Self;
146 impl<S:Encoder> Encodable<S> for uint {
147 fn encode(&self, s: &S) { s.emit_uint(*self) }
150 impl<D:Decoder> Decodable<D> for uint {
151 fn decode(d: &D) -> uint {
156 impl<S:Encoder> Encodable<S> for u8 {
157 fn encode(&self, s: &S) { s.emit_u8(*self) }
160 impl<D:Decoder> Decodable<D> for u8 {
161 fn decode(d: &D) -> u8 {
166 impl<S:Encoder> Encodable<S> for u16 {
167 fn encode(&self, s: &S) { s.emit_u16(*self) }
170 impl<D:Decoder> Decodable<D> for u16 {
171 fn decode(d: &D) -> u16 {
176 impl<S:Encoder> Encodable<S> for u32 {
177 fn encode(&self, s: &S) { s.emit_u32(*self) }
180 impl<D:Decoder> Decodable<D> for u32 {
181 fn decode(d: &D) -> u32 {
186 impl<S:Encoder> Encodable<S> for u64 {
187 fn encode(&self, s: &S) { s.emit_u64(*self) }
190 impl<D:Decoder> Decodable<D> for u64 {
191 fn decode(d: &D) -> u64 {
196 impl<S:Encoder> Encodable<S> for int {
197 fn encode(&self, s: &S) { s.emit_int(*self) }
200 impl<D:Decoder> Decodable<D> for int {
201 fn decode(d: &D) -> int {
206 impl<S:Encoder> Encodable<S> for i8 {
207 fn encode(&self, s: &S) { s.emit_i8(*self) }
210 impl<D:Decoder> Decodable<D> for i8 {
211 fn decode(d: &D) -> i8 {
216 impl<S:Encoder> Encodable<S> for i16 {
217 fn encode(&self, s: &S) { s.emit_i16(*self) }
220 impl<D:Decoder> Decodable<D> for i16 {
221 fn decode(d: &D) -> i16 {
226 impl<S:Encoder> Encodable<S> for i32 {
227 fn encode(&self, s: &S) { s.emit_i32(*self) }
230 impl<D:Decoder> Decodable<D> for i32 {
231 fn decode(d: &D) -> i32 {
236 impl<S:Encoder> Encodable<S> for i64 {
237 fn encode(&self, s: &S) { s.emit_i64(*self) }
240 impl<D:Decoder> Decodable<D> for i64 {
241 fn decode(d: &D) -> i64 {
246 impl<'self, S:Encoder> Encodable<S> for &'self str {
247 fn encode(&self, s: &S) { s.emit_str(*self) }
250 impl<S:Encoder> Encodable<S> for ~str {
251 fn encode(&self, s: &S) { s.emit_str(*self) }
254 impl<D:Decoder> Decodable<D> for ~str {
255 fn decode(d: &D) -> ~str {
260 impl<S:Encoder> Encodable<S> for @str {
261 fn encode(&self, s: &S) { s.emit_str(*self) }
264 impl<D:Decoder> Decodable<D> for @str {
265 fn decode(d: &D) -> @str { d.read_str().to_managed() }
268 impl<S:Encoder> Encodable<S> for float {
269 fn encode(&self, s: &S) { s.emit_float(*self) }
272 impl<D:Decoder> Decodable<D> for float {
273 fn decode(d: &D) -> float {
278 impl<S:Encoder> Encodable<S> for f32 {
279 fn encode(&self, s: &S) { s.emit_f32(*self) }
282 impl<D:Decoder> Decodable<D> for f32 {
283 fn decode(d: &D) -> f32 {
287 impl<S:Encoder> Encodable<S> for f64 {
288 fn encode(&self, s: &S) { s.emit_f64(*self) }
291 impl<D:Decoder> Decodable<D> for f64 {
292 fn decode(d: &D) -> f64 {
297 impl<S:Encoder> Encodable<S> for bool {
298 fn encode(&self, s: &S) { s.emit_bool(*self) }
301 impl<D:Decoder> Decodable<D> for bool {
302 fn decode(d: &D) -> bool {
307 impl<S:Encoder> Encodable<S> for () {
308 fn encode(&self, s: &S) { s.emit_nil() }
311 impl<D:Decoder> Decodable<D> for () {
312 fn decode(d: &D) -> () {
317 impl<'self, S:Encoder,T:Encodable<S>> Encodable<S> for &'self T {
318 fn encode(&self, s: &S) {
323 impl<S:Encoder,T:Encodable<S>> Encodable<S> for ~T {
324 fn encode(&self, s: &S) {
329 impl<D:Decoder,T:Decodable<D>> Decodable<D> for ~T {
330 fn decode(d: &D) -> ~T {
331 ~Decodable::decode(d)
335 impl<S:Encoder,T:Encodable<S>> Encodable<S> for @T {
336 fn encode(&self, s: &S) {
341 impl<D:Decoder,T:Decodable<D>> Decodable<D> for @T {
342 fn decode(d: &D) -> @T {
343 @Decodable::decode(d)
347 impl<'self, S:Encoder,T:Encodable<S>> Encodable<S> for &'self [T] {
348 fn encode(&self, s: &S) {
349 do s.emit_seq(self.len()) {
350 for self.eachi |i, e| {
351 s.emit_seq_elt(i, || e.encode(s))
357 impl<S:Encoder,T:Encodable<S>> Encodable<S> for ~[T] {
358 fn encode(&self, s: &S) {
359 do s.emit_seq(self.len()) {
360 for self.eachi |i, e| {
361 s.emit_seq_elt(i, || e.encode(s))
367 impl<D:Decoder,T:Decodable<D>> Decodable<D> for ~[T] {
368 fn decode(d: &D) -> ~[T] {
369 do d.read_seq |len| {
370 do vec::from_fn(len) |i| {
371 d.read_seq_elt(i, || Decodable::decode(d))
377 impl<S:Encoder,T:Encodable<S>> Encodable<S> for @[T] {
378 fn encode(&self, s: &S) {
379 do s.emit_seq(self.len()) {
380 for self.eachi |i, e| {
381 s.emit_seq_elt(i, || e.encode(s))
387 impl<D:Decoder,T:Decodable<D>> Decodable<D> for @[T] {
388 fn decode(d: &D) -> @[T] {
389 do d.read_seq |len| {
390 do at_vec::from_fn(len) |i| {
391 d.read_seq_elt(i, || Decodable::decode(d))
397 impl<S:Encoder,T:Encodable<S>> Encodable<S> for Option<T> {
398 fn encode(&self, s: &S) {
401 None => s.emit_option_none(),
402 Some(ref v) => s.emit_option_some(|| v.encode(s)),
408 impl<D:Decoder,T:Decodable<D>> Decodable<D> for Option<T> {
409 fn decode(d: &D) -> Option<T> {
410 do d.read_option |b| {
412 Some(Decodable::decode(d))
420 impl<S:Encoder,T0:Encodable<S>,T1:Encodable<S>> Encodable<S> for (T0, T1) {
421 fn encode(&self, s: &S) {
423 (ref t0, ref t1) => {
425 s.emit_seq_elt(0, || t0.encode(s));
426 s.emit_seq_elt(1, || t1.encode(s));
433 impl<D:Decoder,T0:Decodable<D>,T1:Decodable<D>> Decodable<D> for (T0, T1) {
434 fn decode(d: &D) -> (T0, T1) {
435 do d.read_seq |len| {
438 d.read_seq_elt(0, || Decodable::decode(d)),
439 d.read_seq_elt(1, || Decodable::decode(d))
450 > Encodable<S> for (T0, T1, T2) {
451 fn encode(&self, s: &S) {
453 (ref t0, ref t1, ref t2) => {
455 s.emit_seq_elt(0, || t0.encode(s));
456 s.emit_seq_elt(1, || t1.encode(s));
457 s.emit_seq_elt(2, || t2.encode(s));
469 > Decodable<D> for (T0, T1, T2) {
470 fn decode(d: &D) -> (T0, T1, T2) {
471 do d.read_seq |len| {
474 d.read_seq_elt(0, || Decodable::decode(d)),
475 d.read_seq_elt(1, || Decodable::decode(d)),
476 d.read_seq_elt(2, || Decodable::decode(d))
488 > Encodable<S> for (T0, T1, T2, T3) {
489 fn encode(&self, s: &S) {
491 (ref t0, ref t1, ref t2, ref t3) => {
493 s.emit_seq_elt(0, || t0.encode(s));
494 s.emit_seq_elt(1, || t1.encode(s));
495 s.emit_seq_elt(2, || t2.encode(s));
496 s.emit_seq_elt(3, || t3.encode(s));
509 > Decodable<D> for (T0, T1, T2, T3) {
510 fn decode(d: &D) -> (T0, T1, T2, T3) {
511 do d.read_seq |len| {
514 d.read_seq_elt(0, || Decodable::decode(d)),
515 d.read_seq_elt(1, || Decodable::decode(d)),
516 d.read_seq_elt(2, || Decodable::decode(d)),
517 d.read_seq_elt(3, || Decodable::decode(d))
530 > Encodable<S> for (T0, T1, T2, T3, T4) {
531 fn encode(&self, s: &S) {
533 (ref t0, ref t1, ref t2, ref t3, ref t4) => {
535 s.emit_seq_elt(0, || t0.encode(s));
536 s.emit_seq_elt(1, || t1.encode(s));
537 s.emit_seq_elt(2, || t2.encode(s));
538 s.emit_seq_elt(3, || t3.encode(s));
539 s.emit_seq_elt(4, || t4.encode(s));
553 > Decodable<D> for (T0, T1, T2, T3, T4) {
555 -> (T0, T1, T2, T3, T4) {
556 do d.read_seq |len| {
559 d.read_seq_elt(0, || Decodable::decode(d)),
560 d.read_seq_elt(1, || Decodable::decode(d)),
561 d.read_seq_elt(2, || Decodable::decode(d)),
562 d.read_seq_elt(3, || Decodable::decode(d)),
563 d.read_seq_elt(4, || Decodable::decode(d))
571 T: Encodable<S> + Copy
572 > Encodable<S> for @mut DList<T> {
573 fn encode(&self, s: &S) {
574 do s.emit_seq(self.size) {
577 s.emit_seq_elt(i, || e.encode(s));
584 impl<D:Decoder,T:Decodable<D>> Decodable<D> for @mut DList<T> {
585 fn decode(d: &D) -> @mut DList<T> {
587 do d.read_seq |len| {
588 for uint::range(0, len) |i| {
589 list.push(d.read_seq_elt(i, || Decodable::decode(d)));
599 > Encodable<S> for Deque<T> {
600 fn encode(&self, s: &S) {
601 do s.emit_seq(self.len()) {
602 for self.eachi |i, e| {
603 s.emit_seq_elt(i, || e.encode(s));
609 impl<D:Decoder,T:Decodable<D>> Decodable<D> for Deque<T> {
610 fn decode(d: &D) -> Deque<T> {
611 let mut deque = Deque::new();
612 do d.read_seq |len| {
613 for uint::range(0, len) |i| {
614 deque.add_back(d.read_seq_elt(i, || Decodable::decode(d)));
623 K: Encodable<E> + Hash + IterBytes + Eq,
625 > Encodable<E> for HashMap<K, V> {
626 fn encode(&self, e: &E) {
627 do e.emit_map(self.len()) {
629 for self.each |key, val| {
630 e.emit_map_elt_key(i, || key.encode(e));
631 e.emit_map_elt_val(i, || val.encode(e));
640 K: Decodable<D> + Hash + IterBytes + Eq,
642 > Decodable<D> for HashMap<K, V> {
643 fn decode(d: &D) -> HashMap<K, V> {
644 do d.read_map |len| {
645 let mut map = HashMap::with_capacity(len);
646 for uint::range(0, len) |i| {
647 let key = d.read_map_elt_key(i, || Decodable::decode(d));
648 let val = d.read_map_elt_val(i, || Decodable::decode(d));
649 map.insert(key, val);
658 T: Encodable<S> + Hash + IterBytes + Eq
659 > Encodable<S> for HashSet<T> {
660 fn encode(&self, s: &S) {
661 do s.emit_seq(self.len()) {
664 s.emit_seq_elt(i, || e.encode(s));
673 T: Decodable<D> + Hash + IterBytes + Eq
674 > Decodable<D> for HashSet<T> {
675 fn decode(d: &D) -> HashSet<T> {
676 do d.read_seq |len| {
677 let mut set = HashSet::with_capacity(len);
678 for uint::range(0, len) |i| {
679 set.insert(d.read_seq_elt(i, || Decodable::decode(d)));
689 > Encodable<E> for TrieMap<V> {
690 fn encode(&self, e: &E) {
691 do e.emit_map(self.len()) {
693 for self.each |key, val| {
694 e.emit_map_elt_key(i, || key.encode(e));
695 e.emit_map_elt_val(i, || val.encode(e));
705 > Decodable<D> for TrieMap<V> {
706 fn decode(d: &D) -> TrieMap<V> {
707 do d.read_map |len| {
708 let mut map = TrieMap::new();
709 for uint::range(0, len) |i| {
710 let key = d.read_map_elt_key(i, || Decodable::decode(d));
711 let val = d.read_map_elt_val(i, || Decodable::decode(d));
712 map.insert(key, val);
719 impl<S: Encoder> Encodable<S> for TrieSet {
720 fn encode(&self, s: &S) {
721 do s.emit_seq(self.len()) {
724 s.emit_seq_elt(i, || e.encode(s));
731 impl<D: Decoder> Decodable<D> for TrieSet {
732 fn decode(d: &D) -> TrieSet {
733 do d.read_seq |len| {
734 let mut set = TrieSet::new();
735 for uint::range(0, len) |i| {
736 set.insert(d.read_seq_elt(i, || Decodable::decode(d)));
748 K: Encodable<E> + Eq + TotalOrd,
750 > Encodable<E> for TreeMap<K, V> {
751 fn encode(&self, e: &E) {
752 do e.emit_map(self.len()) {
754 for self.each |key, val| {
755 e.emit_map_elt_key(i, || key.encode(e));
756 e.emit_map_elt_val(i, || val.encode(e));
768 K: Decodable<D> + Eq + TotalOrd,
770 > Decodable<D> for TreeMap<K, V> {
771 fn decode(d: &D) -> TreeMap<K, V> {
772 do d.read_map |len| {
773 let mut map = TreeMap::new();
774 for uint::range(0, len) |i| {
775 let key = d.read_map_elt_key(i, || Decodable::decode(d));
776 let val = d.read_map_elt_val(i, || Decodable::decode(d));
777 map.insert(key, val);
789 T: Encodable<S> + Eq + TotalOrd
790 > Encodable<S> for TreeSet<T> {
791 fn encode(&self, s: &S) {
792 do s.emit_seq(self.len()) {
795 s.emit_seq_elt(i, || e.encode(s));
807 T: Decodable<D> + Eq + TotalOrd
808 > Decodable<D> for TreeSet<T> {
809 fn decode(d: &D) -> TreeSet<T> {
810 do d.read_seq |len| {
811 let mut set = TreeSet::new();
812 for uint::range(0, len) |i| {
813 set.insert(d.read_seq_elt(i, || Decodable::decode(d)));
820 // ___________________________________________________________________________
823 // In some cases, these should eventually be coded as traits.
825 pub trait EncoderHelpers {
826 fn emit_from_vec<T>(&self, v: &[T], f: &fn(v: &T));
829 impl<S:Encoder> EncoderHelpers for S {
830 fn emit_from_vec<T>(&self, v: &[T], f: &fn(v: &T)) {
831 do self.emit_seq(v.len()) {
833 do self.emit_seq_elt(i) {
841 pub trait DecoderHelpers {
842 fn read_to_vec<T>(&self, f: &fn() -> T) -> ~[T];
845 impl<D:Decoder> DecoderHelpers for D {
846 fn read_to_vec<T>(&self, f: &fn() -> T) -> ~[T] {
847 do self.read_seq |len| {
848 do vec::from_fn(len) |i| {
849 self.read_seq_elt(i, || f())