src/libserialize/serialize.rs

   1 // Copyright 2012-2014 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.
   4 //
   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.
  10
  11 //! Support code for encoding and decoding types.
  12
  13 /*
  14 Core encoding and decoding interfaces.
  15 */
  16
  17 use std::path;
  18 use std::rc::Rc;
  19
  20 pub trait Encoder<E> {
  21     // Primitive types:
  22     fn emit_nil(&mut self) -> Result<(), E>;
  23     fn emit_uint(&mut self, v: uint) -> Result<(), E>;
  24     fn emit_u64(&mut self, v: u64) -> Result<(), E>;
  25     fn emit_u32(&mut self, v: u32) -> Result<(), E>;
  26     fn emit_u16(&mut self, v: u16) -> Result<(), E>;
  27     fn emit_u8(&mut self, v: u8) -> Result<(), E>;
  28     fn emit_int(&mut self, v: int) -> Result<(), E>;
  29     fn emit_i64(&mut self, v: i64) -> Result<(), E>;
  30     fn emit_i32(&mut self, v: i32) -> Result<(), E>;
  31     fn emit_i16(&mut self, v: i16) -> Result<(), E>;
  32     fn emit_i8(&mut self, v: i8) -> Result<(), E>;
  33     fn emit_bool(&mut self, v: bool) -> Result<(), E>;
  34     fn emit_f64(&mut self, v: f64) -> Result<(), E>;
  35     fn emit_f32(&mut self, v: f32) -> Result<(), E>;
  36     fn emit_char(&mut self, v: char) -> Result<(), E>;
  37     fn emit_str(&mut self, v: &str) -> Result<(), E>;
  38
  39     // Compound types:
  40     fn emit_enum(&mut self, name: &str, f: |&mut Self| -> Result<(), E>) -> Result<(), E>;
  41
  42     fn emit_enum_variant(&mut self,
  43                          v_name: &str,
  44                          v_id: uint,
  45                          len: uint,
  46                          f: |&mut Self| -> Result<(), E>) -> Result<(), E>;
  47     fn emit_enum_variant_arg(&mut self,
  48                              a_idx: uint,
  49                              f: |&mut Self| -> Result<(), E>) -> Result<(), E>;
  50
  51     fn emit_enum_struct_variant(&mut self,
  52                                 v_name: &str,
  53                                 v_id: uint,
  54                                 len: uint,
  55                                 f: |&mut Self| -> Result<(), E>) -> Result<(), E>;
  56     fn emit_enum_struct_variant_field(&mut self,
  57                                       f_name: &str,
  58                                       f_idx: uint,
  59                                       f: |&mut Self| -> Result<(), E>) -> Result<(), E>;
  60
  61     fn emit_struct(&mut self,
  62                    name: &str,
  63                    len: uint,
  64                    f: |&mut Self| -> Result<(), E>) -> Result<(), E>;
  65     fn emit_struct_field(&mut self,
  66                          f_name: &str,
  67                          f_idx: uint,
  68                          f: |&mut Self| -> Result<(), E>) -> Result<(), E>;
  69
  70     fn emit_tuple(&mut self, len: uint, f: |&mut Self| -> Result<(), E>) -> Result<(), E>;
  71     fn emit_tuple_arg(&mut self, idx: uint, f: |&mut Self| -> Result<(), E>) -> Result<(), E>;
  72
  73     fn emit_tuple_struct(&mut self,
  74                          name: &str,
  75                          len: uint,
  76                          f: |&mut Self| -> Result<(), E>) -> Result<(), E>;
  77     fn emit_tuple_struct_arg(&mut self,
  78                              f_idx: uint,
  79                              f: |&mut Self| -> Result<(), E>) -> Result<(), E>;
  80
  81     // Specialized types:
  82     fn emit_option(&mut self, f: |&mut Self| -> Result<(), E>) -> Result<(), E>;
  83     fn emit_option_none(&mut self) -> Result<(), E>;
  84     fn emit_option_some(&mut self, f: |&mut Self| -> Result<(), E>) -> Result<(), E>;
  85
  86     fn emit_seq(&mut self, len: uint, f: |this: &mut Self| -> Result<(), E>) -> Result<(), E>;
  87     fn emit_seq_elt(&mut self, idx: uint, f: |this: &mut Self| -> Result<(), E>) -> Result<(), E>;
  88
  89     fn emit_map(&mut self, len: uint, f: |&mut Self| -> Result<(), E>) -> Result<(), E>;
  90     fn emit_map_elt_key(&mut self, idx: uint, f: |&mut Self| -> Result<(), E>) -> Result<(), E>;
  91     fn emit_map_elt_val(&mut self, idx: uint, f: |&mut Self| -> Result<(), E>) -> Result<(), E>;
  92 }
  93
  94 pub trait Decoder<E> {
  95     // Primitive types:
  96     fn read_nil(&mut self) -> Result<(), E>;
  97     fn read_uint(&mut self) -> Result<uint, E>;
  98     fn read_u64(&mut self) -> Result<u64, E>;
  99     fn read_u32(&mut self) -> Result<u32, E>;
 100     fn read_u16(&mut self) -> Result<u16, E>;
 101     fn read_u8(&mut self) -> Result<u8, E>;
 102     fn read_int(&mut self) -> Result<int, E>;
 103     fn read_i64(&mut self) -> Result<i64, E>;
 104     fn read_i32(&mut self) -> Result<i32, E>;
 105     fn read_i16(&mut self) -> Result<i16, E>;
 106     fn read_i8(&mut self) -> Result<i8, E>;
 107     fn read_bool(&mut self) -> Result<bool, E>;
 108     fn read_f64(&mut self) -> Result<f64, E>;
 109     fn read_f32(&mut self) -> Result<f32, E>;
 110     fn read_char(&mut self) -> Result<char, E>;
 111     fn read_str(&mut self) -> Result<~str, E>;
 112
 113     // Compound types:
 114     fn read_enum<T>(&mut self, name: &str, f: |&mut Self| -> Result<T, E>) -> Result<T, E>;
 115
 116     fn read_enum_variant<T>(&mut self,
 117                             names: &[&str],
 118                             f: |&mut Self, uint| -> Result<T, E>)
 119                             -> Result<T, E>;
 120     fn read_enum_variant_arg<T>(&mut self,
 121                                 a_idx: uint,
 122                                 f: |&mut Self| -> Result<T, E>)
 123                                 -> Result<T, E>;
 124
 125     fn read_enum_struct_variant<T>(&mut self,
 126                                    names: &[&str],
 127                                    f: |&mut Self, uint| -> Result<T, E>)
 128                                    -> Result<T, E>;
 129     fn read_enum_struct_variant_field<T>(&mut self,
 130                                          &f_name: &str,
 131                                          f_idx: uint,
 132                                          f: |&mut Self| -> Result<T, E>)
 133                                          -> Result<T, E>;
 134
 135     fn read_struct<T>(&mut self, s_name: &str, len: uint, f: |&mut Self| -> Result<T, E>)
 136                       -> Result<T, E>;
 137     fn read_struct_field<T>(&mut self,
 138                             f_name: &str,
 139                             f_idx: uint,
 140                             f: |&mut Self| -> Result<T, E>)
 141                             -> Result<T, E>;
 142
 143     fn read_tuple<T>(&mut self, f: |&mut Self, uint| -> Result<T, E>) -> Result<T, E>;
 144     fn read_tuple_arg<T>(&mut self, a_idx: uint, f: |&mut Self| -> Result<T, E>) -> Result<T, E>;
 145
 146     fn read_tuple_struct<T>(&mut self,
 147                             s_name: &str,
 148                             f: |&mut Self, uint| -> Result<T, E>)
 149                             -> Result<T, E>;
 150     fn read_tuple_struct_arg<T>(&mut self,
 151                                 a_idx: uint,
 152                                 f: |&mut Self| -> Result<T, E>)
 153                                 -> Result<T, E>;
 154
 155     // Specialized types:
 156     fn read_option<T>(&mut self, f: |&mut Self, bool| -> Result<T, E>) -> Result<T, E>;
 157
 158     fn read_seq<T>(&mut self, f: |&mut Self, uint| -> Result<T, E>) -> Result<T, E>;
 159     fn read_seq_elt<T>(&mut self, idx: uint, f: |&mut Self| -> Result<T, E>) -> Result<T, E>;
 160
 161     fn read_map<T>(&mut self, f: |&mut Self, uint| -> Result<T, E>) -> Result<T, E>;
 162     fn read_map_elt_key<T>(&mut self, idx: uint, f: |&mut Self| -> Result<T, E>) -> Result<T, E>;
 163     fn read_map_elt_val<T>(&mut self, idx: uint, f: |&mut Self| -> Result<T, E>) -> Result<T, E>;
 164 }
 165
 166 pub trait Encodable<S:Encoder<E>, E> {
 167     fn encode(&self, s: &mut S) -> Result<(), E>;
 168 }
 169
 170 pub trait Decodable<D:Decoder<E>, E> {
 171     fn decode(d: &mut D) -> Result<Self, E>;
 172 }
 173
 174 macro_rules! try ( ($e:expr) => (
 175     match $e { Ok(v) => v, Err(e) => return Err(e) }
 176 ))
 177
 178 impl<E, S:Encoder<E>> Encodable<S, E> for uint {
 179     fn encode(&self, s: &mut S) -> Result<(), E> {
 180         s.emit_uint(*self)
 181     }
 182 }
 183
 184 impl<E, D:Decoder<E>> Decodable<D, E> for uint {
 185     fn decode(d: &mut D) -> Result<uint, E> {
 186         d.read_uint()
 187     }
 188 }
 189
 190 impl<E, S:Encoder<E>> Encodable<S, E> for u8 {
 191     fn encode(&self, s: &mut S) -> Result<(), E> {
 192         s.emit_u8(*self)
 193     }
 194 }
 195
 196 impl<E, D:Decoder<E>> Decodable<D, E> for u8 {
 197     fn decode(d: &mut D) -> Result<u8, E> {
 198         d.read_u8()
 199     }
 200 }
 201
 202 impl<E, S:Encoder<E>> Encodable<S, E> for u16 {
 203     fn encode(&self, s: &mut S) -> Result<(), E> {
 204         s.emit_u16(*self)
 205     }
 206 }
 207
 208 impl<E, D:Decoder<E>> Decodable<D, E> for u16 {
 209     fn decode(d: &mut D) -> Result<u16, E> {
 210         d.read_u16()
 211     }
 212 }
 213
 214 impl<E, S:Encoder<E>> Encodable<S, E> for u32 {
 215     fn encode(&self, s: &mut S) -> Result<(), E> {
 216         s.emit_u32(*self)
 217     }
 218 }
 219
 220 impl<E, D:Decoder<E>> Decodable<D, E> for u32 {
 221     fn decode(d: &mut D) -> Result<u32, E> {
 222         d.read_u32()
 223     }
 224 }
 225
 226 impl<E, S:Encoder<E>> Encodable<S, E> for u64 {
 227     fn encode(&self, s: &mut S) -> Result<(), E> {
 228         s.emit_u64(*self)
 229     }
 230 }
 231
 232 impl<E, D:Decoder<E>> Decodable<D, E> for u64 {
 233     fn decode(d: &mut D) -> Result<u64, E> {
 234         d.read_u64()
 235     }
 236 }
 237
 238 impl<E, S:Encoder<E>> Encodable<S, E> for int {
 239     fn encode(&self, s: &mut S) -> Result<(), E> {
 240         s.emit_int(*self)
 241     }
 242 }
 243
 244 impl<E, D:Decoder<E>> Decodable<D, E> for int {
 245     fn decode(d: &mut D) -> Result<int, E> {
 246         d.read_int()
 247     }
 248 }
 249
 250 impl<E, S:Encoder<E>> Encodable<S, E> for i8 {
 251     fn encode(&self, s: &mut S) -> Result<(), E> {
 252         s.emit_i8(*self)
 253     }
 254 }
 255
 256 impl<E, D:Decoder<E>> Decodable<D, E> for i8 {
 257     fn decode(d: &mut D) -> Result<i8, E> {
 258         d.read_i8()
 259     }
 260 }
 261
 262 impl<E, S:Encoder<E>> Encodable<S, E> for i16 {
 263     fn encode(&self, s: &mut S) -> Result<(), E> {
 264         s.emit_i16(*self)
 265     }
 266 }
 267
 268 impl<E, D:Decoder<E>> Decodable<D, E> for i16 {
 269     fn decode(d: &mut D) -> Result<i16, E> {
 270         d.read_i16()
 271     }
 272 }
 273
 274 impl<E, S:Encoder<E>> Encodable<S, E> for i32 {
 275     fn encode(&self, s: &mut S) -> Result<(), E> {
 276         s.emit_i32(*self)
 277     }
 278 }
 279
 280 impl<E, D:Decoder<E>> Decodable<D, E> for i32 {
 281     fn decode(d: &mut D) -> Result<i32, E> {
 282         d.read_i32()
 283     }
 284 }
 285
 286 impl<E, S:Encoder<E>> Encodable<S, E> for i64 {
 287     fn encode(&self, s: &mut S) -> Result<(), E> {
 288         s.emit_i64(*self)
 289     }
 290 }
 291
 292 impl<E, D:Decoder<E>> Decodable<D, E> for i64 {
 293     fn decode(d: &mut D) -> Result<i64, E> {
 294         d.read_i64()
 295     }
 296 }
 297
 298 impl<'a, E, S:Encoder<E>> Encodable<S, E> for &'a str {
 299     fn encode(&self, s: &mut S) -> Result<(), E> {
 300         s.emit_str(*self)
 301     }
 302 }
 303
 304 impl<E, S:Encoder<E>> Encodable<S, E> for ~str {
 305     fn encode(&self, s: &mut S) -> Result<(), E> {
 306         s.emit_str(*self)
 307     }
 308 }
 309
 310 impl<E, D:Decoder<E>> Decodable<D, E> for ~str {
 311     fn decode(d: &mut D) -> Result<~str, E> {
 312         d.read_str()
 313     }
 314 }
 315
 316 impl<E, S:Encoder<E>> Encodable<S, E> for StrBuf {
 317     fn encode(&self, s: &mut S) -> Result<(), E> {
 318         s.emit_str(self.as_slice())
 319     }
 320 }
 321
 322 impl<E, D:Decoder<E>> Decodable<D, E> for StrBuf {
 323     fn decode(d: &mut D) -> Result<StrBuf, E> {
 324         Ok(StrBuf::from_str(try!(d.read_str())))
 325     }
 326 }
 327
 328 impl<E, S:Encoder<E>> Encodable<S, E> for f32 {
 329     fn encode(&self, s: &mut S) -> Result<(), E> {
 330         s.emit_f32(*self)
 331     }
 332 }
 333
 334 impl<E, D:Decoder<E>> Decodable<D, E> for f32 {
 335     fn decode(d: &mut D) -> Result<f32, E> {
 336         d.read_f32()
 337     }
 338 }
 339
 340 impl<E, S:Encoder<E>> Encodable<S, E> for f64 {
 341     fn encode(&self, s: &mut S) -> Result<(), E> {
 342         s.emit_f64(*self)
 343     }
 344 }
 345
 346 impl<E, D:Decoder<E>> Decodable<D, E> for f64 {
 347     fn decode(d: &mut D) -> Result<f64, E> {
 348         d.read_f64()
 349     }
 350 }
 351
 352 impl<E, S:Encoder<E>> Encodable<S, E> for bool {
 353     fn encode(&self, s: &mut S) -> Result<(), E> {
 354         s.emit_bool(*self)
 355     }
 356 }
 357
 358 impl<E, D:Decoder<E>> Decodable<D, E> for bool {
 359     fn decode(d: &mut D) -> Result<bool, E> {
 360         d.read_bool()
 361     }
 362 }
 363
 364 impl<E, S:Encoder<E>> Encodable<S, E> for char {
 365     fn encode(&self, s: &mut S) -> Result<(), E> {
 366         s.emit_char(*self)
 367     }
 368 }
 369
 370 impl<E, D:Decoder<E>> Decodable<D, E> for char {
 371     fn decode(d: &mut D) -> Result<char, E> {
 372         d.read_char()
 373     }
 374 }
 375
 376 impl<E, S:Encoder<E>> Encodable<S, E> for () {
 377     fn encode(&self, s: &mut S) -> Result<(), E> {
 378         s.emit_nil()
 379     }
 380 }
 381
 382 impl<E, D:Decoder<E>> Decodable<D, E> for () {
 383     fn decode(d: &mut D) -> Result<(), E> {
 384         d.read_nil()
 385     }
 386 }
 387
 388 impl<'a, E, S:Encoder<E>,T:Encodable<S, E>> Encodable<S, E> for &'a T {
 389     fn encode(&self, s: &mut S) -> Result<(), E> {
 390         (**self).encode(s)
 391     }
 392 }
 393
 394 impl<E, S:Encoder<E>,T:Encodable<S, E>> Encodable<S, E> for Box<T> {
 395     fn encode(&self, s: &mut S) -> Result<(), E> {
 396         (**self).encode(s)
 397     }
 398 }
 399
 400 impl<E, D:Decoder<E>,T:Decodable<D, E>> Decodable<D, E> for Box<T> {
 401     fn decode(d: &mut D) -> Result<Box<T>, E> {
 402         Ok(box try!(Decodable::decode(d)))
 403     }
 404 }
 405
 406 impl<E, S:Encoder<E>,T:Encodable<S, E>> Encodable<S, E> for @T {
 407     fn encode(&self, s: &mut S) -> Result<(), E> {
 408         (**self).encode(s)
 409     }
 410 }
 411
 412 impl<E, S:Encoder<E>,T:Encodable<S, E>> Encodable<S, E> for Rc<T> {
 413     #[inline]
 414     fn encode(&self, s: &mut S) -> Result<(), E> {
 415         (**self).encode(s)
 416     }
 417 }
 418
 419 impl<E, D:Decoder<E>,T:Decodable<D, E>> Decodable<D, E> for Rc<T> {
 420     #[inline]
 421     fn decode(d: &mut D) -> Result<Rc<T>, E> {
 422         Ok(Rc::new(try!(Decodable::decode(d))))
 423     }
 424 }
 425
 426 impl<E, D:Decoder<E>,T:Decodable<D, E> + 'static> Decodable<D, E> for @T {
 427     fn decode(d: &mut D) -> Result<@T, E> {
 428         Ok(@try!(Decodable::decode(d)))
 429     }
 430 }
 431
 432 impl<'a, E, S:Encoder<E>,T:Encodable<S, E>> Encodable<S, E> for &'a [T] {
 433     fn encode(&self, s: &mut S) -> Result<(), E> {
 434         s.emit_seq(self.len(), |s| {
 435             for (i, e) in self.iter().enumerate() {
 436                 try!(s.emit_seq_elt(i, |s| e.encode(s)))
 437             }
 438             Ok(())
 439         })
 440     }
 441 }
 442
 443 impl<E, S:Encoder<E>,T:Encodable<S, E>> Encodable<S, E> for ~[T] {
 444     fn encode(&self, s: &mut S) -> Result<(), E> {
 445         s.emit_seq(self.len(), |s| {
 446             for (i, e) in self.iter().enumerate() {
 447                 try!(s.emit_seq_elt(i, |s| e.encode(s)))
 448             }
 449             Ok(())
 450         })
 451     }
 452 }
 453
 454 impl<E, D:Decoder<E>,T:Decodable<D, E>> Decodable<D, E> for ~[T] {
 455     fn decode(d: &mut D) -> Result<~[T], E> {
 456         d.read_seq(|d, len| {
 457             let mut v: Vec<T> = Vec::with_capacity(len);
 458             for i in range(0, len) {
 459                 v.push(try!(d.read_seq_elt(i, |d| Decodable::decode(d))));
 460             }
 461             let k = v.move_iter().collect::<~[T]>();
 462             Ok(k)
 463         })
 464     }
 465 }
 466
 467 impl<E, S:Encoder<E>,T:Encodable<S, E>> Encodable<S, E> for Vec<T> {
 468     fn encode(&self, s: &mut S) -> Result<(), E> {
 469         s.emit_seq(self.len(), |s| {
 470             for (i, e) in self.iter().enumerate() {
 471                 try!(s.emit_seq_elt(i, |s| e.encode(s)))
 472             }
 473             Ok(())
 474         })
 475     }
 476 }
 477
 478 impl<E, D:Decoder<E>,T:Decodable<D, E>> Decodable<D, E> for Vec<T> {
 479     fn decode(d: &mut D) -> Result<Vec<T>, E> {
 480         d.read_seq(|d, len| {
 481             let mut v = Vec::with_capacity(len);
 482             for i in range(0, len) {
 483                 v.push(try!(d.read_seq_elt(i, |d| Decodable::decode(d))));
 484             }
 485             Ok(v)
 486         })
 487     }
 488 }
 489
 490 impl<E, S:Encoder<E>,T:Encodable<S, E>> Encodable<S, E> for Option<T> {
 491     fn encode(&self, s: &mut S) -> Result<(), E> {
 492         s.emit_option(|s| {
 493             match *self {
 494                 None => s.emit_option_none(),
 495                 Some(ref v) => s.emit_option_some(|s| v.encode(s)),
 496             }
 497         })
 498     }
 499 }
 500
 501 impl<E, D:Decoder<E>,T:Decodable<D, E>> Decodable<D, E> for Option<T> {
 502     fn decode(d: &mut D) -> Result<Option<T>, E> {
 503         d.read_option(|d, b| {
 504             if b {
 505                 Ok(Some(try!(Decodable::decode(d))))
 506             } else {
 507                 Ok(None)
 508             }
 509         })
 510     }
 511 }
 512
 513 macro_rules! peel(($name:ident, $($other:ident,)*) => (tuple!($($other,)*)))
 514
 515 macro_rules! tuple (
 516     () => ();
 517     ( $($name:ident,)+ ) => (
 518         impl<E, D:Decoder<E>,$($name:Decodable<D, E>),*> Decodable<D,E> for ($($name,)*) {
 519             #[allow(uppercase_variables)]
 520             fn decode(d: &mut D) -> Result<($($name,)*), E> {
 521                 d.read_tuple(|d, amt| {
 522                     let mut i = 0;
 523                     let ret = ($(try!(d.read_tuple_arg({ i+=1; i-1 }, |d| -> Result<$name,E> {
 524                         Decodable::decode(d)
 525                     })),)*);
 526                     assert!(amt == i,
 527                             "expected tuple of length `{}`, found tuple \
 528                              of length `{}`", i, amt);
 529                     return Ok(ret);
 530                 })
 531             }
 532         }
 533         impl<E, S:Encoder<E>,$($name:Encodable<S, E>),*> Encodable<S, E> for ($($name,)*) {
 534             #[allow(uppercase_variables)]
 535             fn encode(&self, s: &mut S) -> Result<(), E> {
 536                 let ($(ref $name,)*) = *self;
 537                 let mut n = 0;
 538                 $(let $name = $name; n += 1;)*
 539                 s.emit_tuple(n, |s| {
 540                     let mut i = 0;
 541                     $(try!(s.emit_seq_elt({ i+=1; i-1 }, |s| $name.encode(s)));)*
 542                     Ok(())
 543                 })
 544             }
 545         }
 546         peel!($($name,)*)
 547     )
 548 )
 549
 550 tuple! { T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, }
 551
 552 impl<E, S: Encoder<E>> Encodable<S, E> for path::posix::Path {
 553     fn encode(&self, e: &mut S) -> Result<(), E> {
 554         self.as_vec().encode(e)
 555     }
 556 }
 557
 558 impl<E, D: Decoder<E>> Decodable<D, E> for path::posix::Path {
 559     fn decode(d: &mut D) -> Result<path::posix::Path, E> {
 560         let bytes: ~[u8] = try!(Decodable::decode(d));
 561         Ok(path::posix::Path::new(bytes))
 562     }
 563 }
 564
 565 impl<E, S: Encoder<E>> Encodable<S, E> for path::windows::Path {
 566     fn encode(&self, e: &mut S) -> Result<(), E> {
 567         self.as_vec().encode(e)
 568     }
 569 }
 570
 571 impl<E, D: Decoder<E>> Decodable<D, E> for path::windows::Path {
 572     fn decode(d: &mut D) -> Result<path::windows::Path, E> {
 573         let bytes: ~[u8] = try!(Decodable::decode(d));
 574         Ok(path::windows::Path::new(bytes))
 575     }
 576 }
 577
 578 // ___________________________________________________________________________
 579 // Helper routines
 580 //
 581 // In some cases, these should eventually be coded as traits.
 582
 583 pub trait EncoderHelpers<E> {
 584     fn emit_from_vec<T>(&mut self,
 585                         v: &[T],
 586                         f: |&mut Self, v: &T| -> Result<(), E>) -> Result<(), E>;
 587 }
 588
 589 impl<E, S:Encoder<E>> EncoderHelpers<E> for S {
 590     fn emit_from_vec<T>(&mut self, v: &[T], f: |&mut S, &T| -> Result<(), E>) -> Result<(), E> {
 591         self.emit_seq(v.len(), |this| {
 592             for (i, e) in v.iter().enumerate() {
 593                 try!(this.emit_seq_elt(i, |this| {
 594                     f(this, e)
 595                 }));
 596             }
 597             Ok(())
 598         })
 599     }
 600 }
 601
 602 pub trait DecoderHelpers<E> {
 603     fn read_to_vec<T>(&mut self, f: |&mut Self| -> Result<T, E>) -> Result<~[T], E>;
 604 }
 605
 606 impl<E, D:Decoder<E>> DecoderHelpers<E> for D {
 607     fn read_to_vec<T>(&mut self, f: |&mut D| -> Result<T, E>) -> Result<~[T], E> {
 608         self.read_seq(|this, len| {
 609             let mut v = Vec::with_capacity(len);
 610             for i in range(0, len) {
 611                 v.push(try!(this.read_seq_elt(i, |this| f(this))));
 612             }
 613             Ok(v.move_iter().collect())
 614         })
 615     }
 616 }