rustfmt

src/lib.rs

@@ -110,7 +110,10 @@ pub fn decode<T: Decodable>(b: &[u8]) -> DecodingResult<T> {
 /// If this returns an `EncodingError` (other than SizeLimit), assume that the
 /// writer is in an invalid state, as writing could bail out in the middle of
 /// encoding.
-pub fn encode_into<T: Encodable, W: Write>(t: &T, w: &mut W, size_limit: SizeLimit) -> EncodingResult<()> {
+pub fn encode_into<T: Encodable, W: Write>(t: &T,
+                                           w: &mut W,
+                                           size_limit: SizeLimit)
+                                           -> EncodingResult<()> {
     try!(match size_limit {
         SizeLimit::Infinite => Ok(()),
         SizeLimit::Bounded(x) => {
@@ -131,8 +134,7 @@ pub fn encode_into<T: Encodable, W: Write>(t: &T, w: &mut W, size_limit: SizeLim
 /// If this returns an `DecodingError`, assume that the buffer that you passed
 /// in is in an invalid state, as the error could be returned during any point
 /// in the reading.
-pub fn decode_from<R: Read, T: Decodable>(r: &mut R, size_limit: SizeLimit) ->
+pub fn decode_from<R: Read, T: Decodable>(r: &mut R, size_limit: SizeLimit) -> DecodingResult<T> {
-DecodingResult<T> {
     Decodable::decode(&mut reader::DecoderReader::new(r, size_limit))
 }
 

src/reader.rs

@@ -246,15 +246,17 @@ impl<'a, R: Read> Decoder for DecoderReader<'a, R> {
             })),
         }
     }
-    fn read_enum<T, F>(&mut self, _: &str, f: F) -> DecodingResult<T> where
+    fn read_enum<T, F>(&mut self, _: &str, f: F) -> DecodingResult<T>
-        F: FnOnce(&mut DecoderReader<'a, R>) -> DecodingResult<T> {
+        where F: FnOnce(&mut DecoderReader<'a, R>) -> DecodingResult<T>
-            f(self)
+    {
-        }
+        f(self)
-    fn read_enum_variant<T, F>(&mut self, names: &[&str], mut f: F) -> DecodingResult<T> where
+    }
-        F: FnMut(&mut DecoderReader<'a, R>, usize) -> DecodingResult<T> {
+    fn read_enum_variant<T, F>(&mut self, names: &[&str], mut f: F) -> DecodingResult<T>
-            let id = try!(self.read_u32());
+        where F: FnMut(&mut DecoderReader<'a, R>, usize) -> DecodingResult<T>
-            let id = id as usize;
+    {
-            if id >= names.len() {
+        let id = try!(self.read_u32());
+        let id = id as usize;
+        if id >= names.len() {
                 Err(DecodingError::InvalidEncoding(InvalidEncoding {
                     desc: "out of bounds tag when reading enum variant",
                     detail: Some(format!("Expected tag < {}, got {}", names.len(), id))
@@ -262,55 +264,61 @@ impl<'a, R: Read> Decoder for DecoderReader<'a, R> {
             } else {
                 f(self, id)
             }
-        }
+    }
-    fn read_enum_variant_arg<T, F>(&mut self, _: usize, f: F) -> DecodingResult<T> where
+    fn read_enum_variant_arg<T, F>(&mut self, _: usize, f: F) -> DecodingResult<T>
-        F: FnOnce(&mut DecoderReader<'a, R>) -> DecodingResult<T> {
+        where F: FnOnce(&mut DecoderReader<'a, R>) -> DecodingResult<T>
-            f(self)
+    {
-        }
+        f(self)
-    fn read_enum_struct_variant<T, F>(&mut self, names: &[&str], f: F) -> DecodingResult<T> where
+    }
-        F: FnMut(&mut DecoderReader<'a, R>, usize) -> DecodingResult<T> {
+    fn read_enum_struct_variant<T, F>(&mut self, names: &[&str], f: F) -> DecodingResult<T>
-            self.read_enum_variant(names, f)
+        where F: FnMut(&mut DecoderReader<'a, R>, usize) -> DecodingResult<T>
-        }
+    {
+        self.read_enum_variant(names, f)
+    }
     fn read_enum_struct_variant_field<T, F>(&mut self,
                                             _: &str,
                                             f_idx: usize,
                                             f: F)
-        -> DecodingResult<T> where
+                                            -> DecodingResult<T>
-            F: FnOnce(&mut DecoderReader<'a, R>) -> DecodingResult<T> {
+        where F: FnOnce(&mut DecoderReader<'a, R>) -> DecodingResult<T>
-                self.read_enum_variant_arg(f_idx, f)
+    {
-            }
+        self.read_enum_variant_arg(f_idx, f)
-    fn read_struct<T, F>(&mut self, _: &str, _: usize, f: F) -> DecodingResult<T> where
+    }
-        F: FnOnce(&mut DecoderReader<'a, R>) -> DecodingResult<T> {
+    fn read_struct<T, F>(&mut self, _: &str, _: usize, f: F) -> DecodingResult<T>
-            f(self)
+        where F: FnOnce(&mut DecoderReader<'a, R>) -> DecodingResult<T>
-        }
+    {
-    fn read_struct_field<T, F>(&mut self,
+        f(self)
-                               _: &str,
+    }
-                               _: usize,
+    fn read_struct_field<T, F>(&mut self, _: &str, _: usize, f: F) -> DecodingResult<T>
-                               f: F)
+        where F: FnOnce(&mut DecoderReader<'a, R>) -> DecodingResult<T>
-        -> DecodingResult<T> where
+    {
-            F: FnOnce(&mut DecoderReader<'a, R>) -> DecodingResult<T> {
+        f(self)
-                f(self)
+    }
-            }
+    fn read_tuple<T, F>(&mut self, _: usize, f: F) -> DecodingResult<T>
-    fn read_tuple<T, F>(&mut self, _: usize, f: F) -> DecodingResult<T> where
+        where F: FnOnce(&mut DecoderReader<'a, R>) -> DecodingResult<T>
-        F: FnOnce(&mut DecoderReader<'a, R>) -> DecodingResult<T> {
+    {
-            f(self)
+        f(self)
-        }
+    }
-    fn read_tuple_arg<T, F>(&mut self, _: usize, f: F) -> DecodingResult<T> where
+    fn read_tuple_arg<T, F>(&mut self, _: usize, f: F) -> DecodingResult<T>
-        F: FnOnce(&mut DecoderReader<'a, R>) -> DecodingResult<T> {
+        where F: FnOnce(&mut DecoderReader<'a, R>) -> DecodingResult<T>
-            f(self)
+    {
-        }
+        f(self)
-    fn read_tuple_struct<T, F>(&mut self, _: &str, len: usize, f: F) -> DecodingResult<T> where
+    }
-        F: FnOnce(&mut DecoderReader<'a, R>) -> DecodingResult<T> {
+    fn read_tuple_struct<T, F>(&mut self, _: &str, len: usize, f: F) -> DecodingResult<T>
-            self.read_tuple(len, f)
+        where F: FnOnce(&mut DecoderReader<'a, R>) -> DecodingResult<T>
-        }
+    {
-    fn read_tuple_struct_arg<T, F>(&mut self, a_idx: usize, f: F) -> DecodingResult<T> where
+        self.read_tuple(len, f)
-        F: FnOnce(&mut DecoderReader<'a, R>) -> DecodingResult<T> {
+    }
-            self.read_tuple_arg(a_idx, f)
+    fn read_tuple_struct_arg<T, F>(&mut self, a_idx: usize, f: F) -> DecodingResult<T>
-        }
+        where F: FnOnce(&mut DecoderReader<'a, R>) -> DecodingResult<T>
-    fn read_option<T, F>(&mut self, mut f: F) -> DecodingResult<T> where
+    {
-        F: FnMut(&mut DecoderReader<'a, R>, bool) -> DecodingResult<T> {
+        self.read_tuple_arg(a_idx, f)
-            let x = try!(self.read_u8());
+    }
-            match x {
+    fn read_option<T, F>(&mut self, mut f: F) -> DecodingResult<T>
+        where F: FnMut(&mut DecoderReader<'a, R>, bool) -> DecodingResult<T>
+    {
+        let x = try!(self.read_u8());
+        match x {
                 1 => f(self, true),
                 0 => f(self, false),
                 _ => Err(DecodingError::InvalidEncoding(InvalidEncoding {
@@ -318,29 +326,34 @@ impl<'a, R: Read> Decoder for DecoderReader<'a, R> {
                     detail: Some(format!("Expected 0 or 1, got {}", x))
                 })),
             }
-        }
+    }
-    fn read_seq<T, F>(&mut self, f: F) -> DecodingResult<T> where
+    fn read_seq<T, F>(&mut self, f: F) -> DecodingResult<T>
-        F: FnOnce(&mut DecoderReader<'a, R>, usize) -> DecodingResult<T> {
+        where F: FnOnce(&mut DecoderReader<'a, R>, usize) -> DecodingResult<T>
-            let len = try!(self.read_usize());
+    {
-            f(self, len)
+        let len = try!(self.read_usize());
-        }
+        f(self, len)
-    fn read_seq_elt<T, F>(&mut self, _: usize, f: F) -> DecodingResult<T> where
+    }
-        F: FnOnce(&mut DecoderReader<'a, R>) -> DecodingResult<T> {
+    fn read_seq_elt<T, F>(&mut self, _: usize, f: F) -> DecodingResult<T>
-            f(self)
+        where F: FnOnce(&mut DecoderReader<'a, R>) -> DecodingResult<T>
-        }
+    {
-    fn read_map<T, F>(&mut self, f: F) -> DecodingResult<T> where
+        f(self)
-        F: FnOnce(&mut DecoderReader<'a, R>, usize) -> DecodingResult<T> {
+    }
-            let len = try!(self.read_usize());
+    fn read_map<T, F>(&mut self, f: F) -> DecodingResult<T>
-            f(self, len)
+        where F: FnOnce(&mut DecoderReader<'a, R>, usize) -> DecodingResult<T>
-        }
+    {
-    fn read_map_elt_key<T, F>(&mut self, _: usize, f: F) -> DecodingResult<T> where
+        let len = try!(self.read_usize());
-        F: FnOnce(&mut DecoderReader<'a, R>) -> DecodingResult<T> {
+        f(self, len)
-            f(self)
+    }
-        }
+    fn read_map_elt_key<T, F>(&mut self, _: usize, f: F) -> DecodingResult<T>
-    fn read_map_elt_val<T, F>(&mut self, _: usize, f: F) -> DecodingResult<T> where
+        where F: FnOnce(&mut DecoderReader<'a, R>) -> DecodingResult<T>
-        F: FnOnce(&mut DecoderReader<'a, R>) -> DecodingResult<T> {
+    {
-            f(self)
+        f(self)
-        }
+    }
+    fn read_map_elt_val<T, F>(&mut self, _: usize, f: F) -> DecodingResult<T>
+        where F: FnOnce(&mut DecoderReader<'a, R>) -> DecodingResult<T>
+    {
+        f(self)
+    }
     fn error(&mut self, err: &str) -> DecodingError {
         DecodingError::InvalidEncoding(InvalidEncoding {
             desc: "user-induced error",

src/test.rs

@@ -2,31 +2,21 @@ use std::fmt::Debug;
 use std::collections::HashMap;
 use std::ops::Deref;
 
-use rustc_serialize::{
+use rustc_serialize::{Encoder, Decoder, Encodable, Decodable};
-    Encoder,
-    Decoder,
-    Encodable,
-    Decodable
-};
 
-use super::{
+use super::{encode, decode, decode_from, encoded_size, DecodingError,
-    encode,
+            DecodingResult, RefBox};
-    decode,
-    decode_from,
-    encoded_size,
-    DecodingError,
-    DecodingResult,
-    RefBox,
-};
 
 use super::SizeLimit::{Infinite, Bounded};
 
 fn the_same<V>(element: V)
-where V: Encodable + Decodable + PartialEq + Debug + 'static {
+    where V: Encodable+Decodable+PartialEq+Debug+'static
+{
 
     // Make sure that the bahavior isize correct when wrapping with a RefBox.
     fn ref_box_correct<V>(v: &V) -> bool
-    where V: Encodable + Decodable + PartialEq + Debug + 'static {
+        where V: Encodable+Decodable+PartialEq+Debug+'static
+    {
         let rf = RefBox::new(v);
 
         let encoded = encode(&rf, Infinite).unwrap();
@@ -169,7 +159,7 @@ fn many() {
 }
 
 #[test]
-fn map(){
+fn map() {
     let mut m = HashMap::new();
     m.insert(4u64, "foo".to_string());
     m.insert(0u64, "bar".to_string());
@@ -177,7 +167,7 @@ fn map(){
 }
 
 #[test]
-fn boole(){
+fn boole() {
     the_same(true);
     the_same(false);
 }

src/writer.rs

@@ -105,7 +105,9 @@ impl SizeChecker {
 impl<'a, W: Write> Encoder for EncoderWriter<'a, W> {
     type Error = EncodingError;
 
-    fn emit_nil(&mut self) -> EncodingResult<()> { Ok(()) }
+    fn emit_nil(&mut self) -> EncodingResult<()> {
+        Ok(())
+    }
     fn emit_usize(&mut self, v: usize) -> EncodingResult<()> {
         self.emit_u64(v as u64)
     }
@@ -160,105 +162,121 @@ impl<'a, W: Write> Encoder for EncoderWriter<'a, W> {
         try!(self.emit_usize(v.len()));
         self.writer.write_all(v.as_bytes()).map_err(EncodingError::IoError)
     }
-    fn emit_enum<F>(&mut self, __: &str, f: F) -> EncodingResult<()> where
+    fn emit_enum<F>(&mut self, __: &str, f: F) -> EncodingResult<()>
-        F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()> {
+        where F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()>
-            f(self)
+    {
-        }
+        f(self)
-    fn emit_enum_variant<F>(&mut self, _: &str,
+    }
-                            v_id: usize,
+    fn emit_enum_variant<F>(&mut self, _: &str, v_id: usize, _: usize, f: F) -> EncodingResult<()>
-                            _: usize,
+        where F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()>
-                            f: F) -> EncodingResult<()> where
+    {
-        F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()> {
+        let max_u32: u32 = ::std::u32::MAX;
-            let max_u32: u32 = ::std::u32::MAX;
+        if v_id > (max_u32 as usize) {
-            if v_id > (max_u32 as usize) {
                 panic!("Variant tag doesn't fit in a u32")
             }
-            try!(self.emit_u32(v_id as u32));
+        try!(self.emit_u32(v_id as u32));
-            f(self)
+        f(self)
-        }
+    }
-    fn emit_enum_variant_arg<F>(&mut self, _: usize, f: F) -> EncodingResult<()> where
+    fn emit_enum_variant_arg<F>(&mut self, _: usize, f: F) -> EncodingResult<()>
-        F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()> {
+        where F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()>
-            f(self)
+    {
-        }
+        f(self)
-    fn emit_enum_struct_variant<F>(&mut self, _: &str,
+    }
+    fn emit_enum_struct_variant<F>(&mut self,
+                                   _: &str,
                                    _: usize,
                                    _: usize,
-                                   f: F) -> EncodingResult<()> where
+                                   f: F)
-        F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()> {
+                                   -> EncodingResult<()>
-            f(self)
+        where F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()>
-        }
+    {
-    fn emit_enum_struct_variant_field<F>(&mut self,
+        f(self)
-                                         _: &str,
+    }
-                                         _: usize,
+    fn emit_enum_struct_variant_field<F>(&mut self, _: &str, _: usize, f: F) -> EncodingResult<()>
-                                         f: F) -> EncodingResult<()> where
+        where F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()>
-        F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()> {
+    {
-            f(self)
+        f(self)
-        }
+    }
-    fn emit_struct<F>(&mut self, _: &str, _: usize, f: F) -> EncodingResult<()> where
+    fn emit_struct<F>(&mut self, _: &str, _: usize, f: F) -> EncodingResult<()>
-        F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()> {
+        where F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()>
-            f(self)
+    {
-        }
+        f(self)
-    fn emit_struct_field<F>(&mut self, _: &str, _: usize, f: F) -> EncodingResult<()> where
+    }
-        F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()> {
+    fn emit_struct_field<F>(&mut self, _: &str, _: usize, f: F) -> EncodingResult<()>
-            f(self)
+        where F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()>
-        }
+    {
-    fn emit_tuple<F>(&mut self, _: usize, f: F) -> EncodingResult<()> where
+        f(self)
-        F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()> {
+    }
-            f(self)
+    fn emit_tuple<F>(&mut self, _: usize, f: F) -> EncodingResult<()>
-        }
+        where F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()>
-    fn emit_tuple_arg<F>(&mut self, _: usize, f: F) -> EncodingResult<()> where
+    {
-        F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()> {
+        f(self)
-            f(self)
+    }
-        }
+    fn emit_tuple_arg<F>(&mut self, _: usize, f: F) -> EncodingResult<()>
-    fn emit_tuple_struct<F>(&mut self, _: &str, len: usize, f: F) -> EncodingResult<()> where
+        where F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()>
-        F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()> {
+    {
-            self.emit_tuple(len, f)
+        f(self)
-        }
+    }
-    fn emit_tuple_struct_arg<F>(&mut self, f_idx: usize, f: F) -> EncodingResult<()> where
+    fn emit_tuple_struct<F>(&mut self, _: &str, len: usize, f: F) -> EncodingResult<()>
-        F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()> {
+        where F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()>
-            self.emit_tuple_arg(f_idx, f)
+    {
-        }
+        self.emit_tuple(len, f)
-    fn emit_option<F>(&mut self, f: F) -> EncodingResult<()> where
+    }
-        F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()> {
+    fn emit_tuple_struct_arg<F>(&mut self, f_idx: usize, f: F) -> EncodingResult<()>
-            f(self)
+        where F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()>
-        }
+    {
+        self.emit_tuple_arg(f_idx, f)
+    }
+    fn emit_option<F>(&mut self, f: F) -> EncodingResult<()>
+        where F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()>
+    {
+        f(self)
+    }
     fn emit_option_none(&mut self) -> EncodingResult<()> {
         self.writer.write_u8(0).map_err(wrap_io)
     }
-    fn emit_option_some<F>(&mut self, f: F) -> EncodingResult<()> where
+    fn emit_option_some<F>(&mut self, f: F) -> EncodingResult<()>
-        F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()> {
+        where F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()>
-            try!(self.writer.write_u8(1).map_err(wrap_io));
+    {
-            f(self)
+        try!(self.writer.write_u8(1).map_err(wrap_io));
-        }
+        f(self)
-    fn emit_seq<F>(&mut self, len: usize, f: F) -> EncodingResult<()> where
+    }
-        F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()> {
+    fn emit_seq<F>(&mut self, len: usize, f: F) -> EncodingResult<()>
-            try!(self.emit_usize(len));
+        where F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()>
-            f(self)
+    {
-        }
+        try!(self.emit_usize(len));
-    fn emit_seq_elt<F>(&mut self, _: usize, f: F) -> EncodingResult<()> where
+        f(self)
-        F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()> {
+    }
-            f(self)
+    fn emit_seq_elt<F>(&mut self, _: usize, f: F) -> EncodingResult<()>
-        }
+        where F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()>
-    fn emit_map<F>(&mut self, len: usize, f: F) -> EncodingResult<()> where
+    {
-        F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()> {
+        f(self)
-            try!(self.emit_usize(len));
+    }
-            f(self)
+    fn emit_map<F>(&mut self, len: usize, f: F) -> EncodingResult<()>
-        }
+        where F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()>
-    fn emit_map_elt_key<F>(&mut self, _: usize, f: F) -> EncodingResult<()> where
+    {
-        F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()> {
+        try!(self.emit_usize(len));
-            f(self)
+        f(self)
-        }
+    }
-    fn emit_map_elt_val<F>(&mut self, _: usize, f: F) -> EncodingResult<()> where
+    fn emit_map_elt_key<F>(&mut self, _: usize, f: F) -> EncodingResult<()>
-        F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()> {
+        where F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()>
-            f(self)
+    {
-        }
+        f(self)
+    }
+    fn emit_map_elt_val<F>(&mut self, _: usize, f: F) -> EncodingResult<()>
+        where F: FnOnce(&mut EncoderWriter<'a, W>) -> EncodingResult<()>
+    {
+        f(self)
+    }
 
 }
 
 impl Encoder for SizeChecker {
     type Error = EncodingError;
 
-    fn emit_nil(&mut self) -> EncodingResult<()> { Ok(()) }
+    fn emit_nil(&mut self) -> EncodingResult<()> {
+        Ok(())
+    }
     fn emit_usize(&mut self, v: usize) -> EncodingResult<()> {
         self.add_value(v as u64)
     }
@@ -305,93 +323,107 @@ impl Encoder for SizeChecker {
         try!(self.add_value(0 as u64));
         self.add_raw(v.len())
     }
-    fn emit_enum<F>(&mut self, __: &str, f: F) -> EncodingResult<()> where
+    fn emit_enum<F>(&mut self, __: &str, f: F) -> EncodingResult<()>
-        F: FnOnce(&mut SizeChecker) -> EncodingResult<()> {
+        where F: FnOnce(&mut SizeChecker) -> EncodingResult<()>
-            f(self)
+    {
-        }
+        f(self)
-    fn emit_enum_variant<F>(&mut self, _: &str,
+    }
-                            v_id: usize,
+    fn emit_enum_variant<F>(&mut self, _: &str, v_id: usize, _: usize, f: F) -> EncodingResult<()>
-                            _: usize,
+        where F: FnOnce(&mut SizeChecker) -> EncodingResult<()>
-                            f: F) -> EncodingResult<()> where
+    {
-        F: FnOnce(&mut SizeChecker) -> EncodingResult<()> {
+        try!(self.add_value(v_id as u32));
-            try!(self.add_value(v_id as u32));
+        f(self)
-            f(self)
+    }
-        }
+    fn emit_enum_variant_arg<F>(&mut self, _: usize, f: F) -> EncodingResult<()>
-    fn emit_enum_variant_arg<F>(&mut self, _: usize, f: F) -> EncodingResult<()> where
+        where F: FnOnce(&mut SizeChecker) -> EncodingResult<()>
-        F: FnOnce(&mut SizeChecker) -> EncodingResult<()> {
+    {
-            f(self)
+        f(self)
-        }
+    }
-    fn emit_enum_struct_variant<F>(&mut self, _: &str,
+    fn emit_enum_struct_variant<F>(&mut self,
+                                   _: &str,
                                    _: usize,
                                    _: usize,
-                                   f: F) -> EncodingResult<()> where
+                                   f: F)
-        F: FnOnce(&mut SizeChecker) -> EncodingResult<()> {
+                                   -> EncodingResult<()>
-            f(self)
+        where F: FnOnce(&mut SizeChecker) -> EncodingResult<()>
-        }
+    {
-    fn emit_enum_struct_variant_field<F>(&mut self,
+        f(self)
-                                         _: &str,
+    }
-                                         _: usize,
+    fn emit_enum_struct_variant_field<F>(&mut self, _: &str, _: usize, f: F) -> EncodingResult<()>
-                                         f: F) -> EncodingResult<()> where
+        where F: FnOnce(&mut SizeChecker) -> EncodingResult<()>
-        F: FnOnce(&mut SizeChecker) -> EncodingResult<()> {
+    {
-            f(self)
+        f(self)
-        }
+    }
-    fn emit_struct<F>(&mut self, _: &str, _: usize, f: F) -> EncodingResult<()> where
+    fn emit_struct<F>(&mut self, _: &str, _: usize, f: F) -> EncodingResult<()>
-        F: FnOnce(&mut SizeChecker) -> EncodingResult<()> {
+        where F: FnOnce(&mut SizeChecker) -> EncodingResult<()>
-            f(self)
+    {
-        }
+        f(self)
-    fn emit_struct_field<F>(&mut self, _: &str, _: usize, f: F) -> EncodingResult<()> where
+    }
-        F: FnOnce(&mut SizeChecker) -> EncodingResult<()> {
+    fn emit_struct_field<F>(&mut self, _: &str, _: usize, f: F) -> EncodingResult<()>
-            f(self)
+        where F: FnOnce(&mut SizeChecker) -> EncodingResult<()>
-        }
+    {
-    fn emit_tuple<F>(&mut self, _: usize, f: F) -> EncodingResult<()> where
+        f(self)
-        F: FnOnce(&mut SizeChecker) -> EncodingResult<()> {
+    }
-            f(self)
+    fn emit_tuple<F>(&mut self, _: usize, f: F) -> EncodingResult<()>
-        }
+        where F: FnOnce(&mut SizeChecker) -> EncodingResult<()>
-    fn emit_tuple_arg<F>(&mut self, _: usize, f: F) -> EncodingResult<()> where
+    {
-        F: FnOnce(&mut SizeChecker) -> EncodingResult<()> {
+        f(self)
-            f(self)
+    }
-        }
+    fn emit_tuple_arg<F>(&mut self, _: usize, f: F) -> EncodingResult<()>
-    fn emit_tuple_struct<F>(&mut self, _: &str, len: usize, f: F) -> EncodingResult<()> where
+        where F: FnOnce(&mut SizeChecker) -> EncodingResult<()>
-        F: FnOnce(&mut SizeChecker) -> EncodingResult<()> {
+    {
-            self.emit_tuple(len, f)
+        f(self)
-        }
+    }
-    fn emit_tuple_struct_arg<F>(&mut self, f_idx: usize, f: F) -> EncodingResult<()> where
+    fn emit_tuple_struct<F>(&mut self, _: &str, len: usize, f: F) -> EncodingResult<()>
-        F: FnOnce(&mut SizeChecker) -> EncodingResult<()> {
+        where F: FnOnce(&mut SizeChecker) -> EncodingResult<()>
-            self.emit_tuple_arg(f_idx, f)
+    {
-        }
+        self.emit_tuple(len, f)
-    fn emit_option<F>(&mut self, f: F) -> EncodingResult<()> where
+    }
-        F: FnOnce(&mut SizeChecker) -> EncodingResult<()> {
+    fn emit_tuple_struct_arg<F>(&mut self, f_idx: usize, f: F) -> EncodingResult<()>
-            f(self)
+        where F: FnOnce(&mut SizeChecker) -> EncodingResult<()>
-        }
+    {
+        self.emit_tuple_arg(f_idx, f)
+    }
+    fn emit_option<F>(&mut self, f: F) -> EncodingResult<()>
+        where F: FnOnce(&mut SizeChecker) -> EncodingResult<()>
+    {
+        f(self)
+    }
     fn emit_option_none(&mut self) -> EncodingResult<()> {
         self.add_value(0 as u8)
     }
-    fn emit_option_some<F>(&mut self, f: F) -> EncodingResult<()> where
+    fn emit_option_some<F>(&mut self, f: F) -> EncodingResult<()>
-        F: FnOnce(&mut SizeChecker) -> EncodingResult<()> {
+        where F: FnOnce(&mut SizeChecker) -> EncodingResult<()>
-            try!(self.add_value(1 as u8));
+    {
-            f(self)
+        try!(self.add_value(1 as u8));
-        }
+        f(self)
-    fn emit_seq<F>(&mut self, len: usize, f: F) -> EncodingResult<()> where
+    }
-        F: FnOnce(&mut SizeChecker) -> EncodingResult<()> {
+    fn emit_seq<F>(&mut self, len: usize, f: F) -> EncodingResult<()>
-            try!(self.emit_usize(len));
+        where F: FnOnce(&mut SizeChecker) -> EncodingResult<()>
-            f(self)
+    {
-        }
+        try!(self.emit_usize(len));
-    fn emit_seq_elt<F>(&mut self, _: usize, f: F) -> EncodingResult<()> where
+        f(self)
-        F: FnOnce(&mut SizeChecker) -> EncodingResult<()> {
+    }
-            f(self)
+    fn emit_seq_elt<F>(&mut self, _: usize, f: F) -> EncodingResult<()>
-        }
+        where F: FnOnce(&mut SizeChecker) -> EncodingResult<()>
-    fn emit_map<F>(&mut self, len: usize, f: F) -> EncodingResult<()> where
+    {
-        F: FnOnce(&mut SizeChecker) -> EncodingResult<()> {
+        f(self)
-            try!(self.emit_usize(len));
+    }
-            f(self)
+    fn emit_map<F>(&mut self, len: usize, f: F) -> EncodingResult<()>
-        }
+        where F: FnOnce(&mut SizeChecker) -> EncodingResult<()>
-    fn emit_map_elt_key<F>(&mut self, _: usize, f: F) -> EncodingResult<()> where
+    {
-        F: FnOnce(&mut SizeChecker) -> EncodingResult<()> {
+        try!(self.emit_usize(len));
-            f(self)
+        f(self)
-        }
+    }
-    fn emit_map_elt_val<F>(&mut self, _: usize, f: F) -> EncodingResult<()> where
+    fn emit_map_elt_key<F>(&mut self, _: usize, f: F) -> EncodingResult<()>
-        F: FnOnce(&mut SizeChecker) -> EncodingResult<()> {
+        where F: FnOnce(&mut SizeChecker) -> EncodingResult<()>
-            f(self)
+    {
-        }
+        f(self)
+    }
+    fn emit_map_elt_val<F>(&mut self, _: usize, f: F) -> EncodingResult<()>
+        where F: FnOnce(&mut SizeChecker) -> EncodingResult<()>
+    {
+        f(self)
+    }
 
 }