cargo fmt source

examples/basic.rs

@@ -2,7 +2,7 @@
 extern crate serde_derive;
 extern crate bincode;
 
-use bincode::{serialize, deserialize, Infinite};
+use bincode::{deserialize, serialize, Infinite};
 
 #[derive(Serialize, Deserialize, PartialEq, Debug)]
 struct Entity {

src/de/mod.rs

@@ -5,7 +5,7 @@ use byteorder::{ReadBytesExt, ByteOrder};
 use serde_crate as serde;
 use serde_crate::de::IntoDeserializer;
 use serde_crate::de::Error as DeError;
-use ::SizeLimit;
+use SizeLimit;
 use super::{Result, Error, ErrorKind};
 use self::read::BincodeRead;
 
@@ -36,7 +36,7 @@ impl<'de, R: BincodeRead<'de>, E: ByteOrder, S: SizeLimit> Deserializer<R, S, E>
         Deserializer {
             reader: r,
             size_limit: size_limit,
-            _phantom: PhantomData
+            _phantom: PhantomData,
         }
     }
 
@@ -57,8 +57,7 @@ impl<'de, R: BincodeRead<'de>, E: ByteOrder, S: SizeLimit> Deserializer<R, S, E>
 
     fn read_string(&mut self) -> Result<String> {
         let vec = self.read_vec()?;
-        String::from_utf8(vec).map_err(|e|
+        String::from_utf8(vec).map_err(|e| ErrorKind::InvalidUtf8Encoding(e.utf8_error()).into())
-            ErrorKind::InvalidUtf8Encoding(e.utf8_error()).into())
     }
 }
 
@@ -76,26 +75,30 @@ macro_rules! impl_nums {
 }
 
 impl<'de, 'a, R, S, E> serde::Deserializer<'de> for &'a mut Deserializer<R, S, E>
-where R: BincodeRead<'de>, S: SizeLimit, E: ByteOrder {
+where
+    R: BincodeRead<'de>,
+    S: SizeLimit,
+    E: ByteOrder,
+{
     type Error = Error;
 
     #[inline]
     fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value>
-        where V: serde::de::Visitor<'de>,
+    where
+        V: serde::de::Visitor<'de>,
     {
         Err(Box::new(ErrorKind::DeserializeAnyNotSupported))
     }
 
     fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value>
-        where V: serde::de::Visitor<'de>,
+    where
+        V: serde::de::Visitor<'de>,
     {
         let value: u8 = try!(serde::Deserialize::deserialize(self));
         match value {
             1 => visitor.visit_bool(true),
             0 => visitor.visit_bool(false),
-            value => {
+            value => Err(ErrorKind::InvalidBoolEncoding(value).into()),
-                Err(ErrorKind::InvalidBoolEncoding(value).into())
-            }
         }
     }
 
@@ -111,7 +114,8 @@ where R: BincodeRead<'de>, S: SizeLimit, E: ByteOrder {
 
     #[inline]
     fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value>
-        where V: serde::de::Visitor<'de>,
+    where
+        V: serde::de::Visitor<'de>,
     {
         try!(self.read_type::<u8>());
         visitor.visit_u8(try!(self.reader.read_u8()))
@@ -119,45 +123,56 @@ where R: BincodeRead<'de>, S: SizeLimit, E: ByteOrder {
 
     #[inline]
     fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value>
-        where V: serde::de::Visitor<'de>,
+    where
+        V: serde::de::Visitor<'de>,
     {
         try!(self.read_type::<i8>());
         visitor.visit_i8(try!(self.reader.read_i8()))
     }
 
     fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
-        where V: serde::de::Visitor<'de>,
+    where
+        V: serde::de::Visitor<'de>,
     {
         visitor.visit_unit()
     }
 
     fn deserialize_char<V>(self, visitor: V) -> Result<V::Value>
-        where V: serde::de::Visitor<'de>,
+    where
+        V: serde::de::Visitor<'de>,
     {
         use std::str;
 
-        let error = || {
+        let error = || ErrorKind::InvalidCharEncoding.into();
-            ErrorKind::InvalidCharEncoding.into()
-        };
 
         let mut buf = [0u8; 4];
 
         // Look at the first byte to see how many bytes must be read
         let _ = try!(self.reader.read_exact(&mut buf[..1]));
         let width = utf8_char_width(buf[0]);
-        if width == 1 { return visitor.visit_char(buf[0] as char) }
+        if width == 1 {
-        if width == 0 { return Err(error())}
+            return visitor.visit_char(buf[0] as char);
+        }
+        if width == 0 {
+            return Err(error());
+        }
 
         if self.reader.read_exact(&mut buf[1..width]).is_err() {
             return Err(error());
         }
 
-        let res = try!(str::from_utf8(&buf[..width]).ok().and_then(|s| s.chars().next()).ok_or(error()));
+        let res = try!(
+            str::from_utf8(&buf[..width])
+                .ok()
+                .and_then(|s| s.chars().next())
+                .ok_or(error())
+        );
         visitor.visit_char(res)
     }
 
     fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
-        where V: serde::de::Visitor<'de>,
+    where
+        V: serde::de::Visitor<'de>,
     {
         let len: usize = try!(serde::Deserialize::deserialize(&mut *self));
         try!(self.read_bytes(len as u64));
@@ -165,13 +180,15 @@ where R: BincodeRead<'de>, S: SizeLimit, E: ByteOrder {
     }
 
     fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>
-        where V: serde::de::Visitor<'de>,
+    where
+        V: serde::de::Visitor<'de>,
     {
         visitor.visit_string(try!(self.read_string()))
     }
 
     fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value>
-        where V: serde::de::Visitor<'de>,
+    where
+        V: serde::de::Visitor<'de>,
     {
         let len: usize = try!(serde::Deserialize::deserialize(&mut *self));
         try!(self.read_bytes(len as u64));
@@ -179,16 +196,20 @@ where R: BincodeRead<'de>, S: SizeLimit, E: ByteOrder {
     }
 
     fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value>
-        where V: serde::de::Visitor<'de>,
+    where
+        V: serde::de::Visitor<'de>,
     {
         visitor.visit_byte_buf(try!(self.read_vec()))
     }
 
-    fn deserialize_enum<V>(self,
+    fn deserialize_enum<V>(
-                     _enum: &'static str,
+        self,
-                     _variants: &'static [&'static str],
+        _enum: &'static str,
-                     visitor: V) -> Result<V::Value>
+        _variants: &'static [&'static str],
-        where V: serde::de::Visitor<'de>,
+        visitor: V,
+    ) -> Result<V::Value>
+    where
+        V: serde::de::Visitor<'de>,
     {
         impl<'de, 'a, R: 'a, S, E> serde::de::EnumAccess<'de> for &'a mut Deserializer<R, S, E>
         where R: BincodeRead<'de>, S: SizeLimit, E: ByteOrder {
@@ -207,25 +228,35 @@ where R: BincodeRead<'de>, S: SizeLimit, E: ByteOrder {
         visitor.visit_enum(self)
     }
 
-    fn deserialize_tuple<V>(self,
+    fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value>
-                            len: usize,
+    where
-                            visitor: V) -> Result<V::Value>
+        V: serde::de::Visitor<'de>,
-        where V: serde::de::Visitor<'de>,
     {
         struct Access<'a, R: Read + 'a, S: SizeLimit + 'a, E: ByteOrder + 'a> {
             deserializer: &'a mut Deserializer<R, S, E>,
             len: usize,
         }
 
-        impl<'de, 'a, 'b: 'a, R: BincodeRead<'de>+ 'b, S: SizeLimit, E: ByteOrder> serde::de::SeqAccess<'de> for Access<'a, R, S, E> {
+        impl<
+            'de,
+            'a,
+            'b: 'a,
+            R: BincodeRead<'de> + 'b,
+            S: SizeLimit,
+            E: ByteOrder,
+        > serde::de::SeqAccess<'de> for Access<'a, R, S, E> {
             type Error = Error;
 
             fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
-                where T: serde::de::DeserializeSeed<'de>,
+            where
+                T: serde::de::DeserializeSeed<'de>,
             {
                 if self.len > 0 {
                     self.len -= 1;
-                    let value = try!(serde::de::DeserializeSeed::deserialize(seed, &mut *self.deserializer));
+                    let value = try!(serde::de::DeserializeSeed::deserialize(
+                        seed,
+                        &mut *self.deserializer,
+                    ));
                     Ok(Some(value))
                 } else {
                     Ok(None)
@@ -237,22 +268,27 @@ where R: BincodeRead<'de>, S: SizeLimit, E: ByteOrder {
             }
         }
 
-        visitor.visit_seq(Access { deserializer: self, len: len })
+        visitor.visit_seq(Access {
+            deserializer: self,
+            len: len,
+        })
     }
 
     fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
-        where V: serde::de::Visitor<'de>,
+    where
+        V: serde::de::Visitor<'de>,
     {
         let value: u8 = try!(serde::de::Deserialize::deserialize(&mut *self));
         match value {
             0 => visitor.visit_none(),
             1 => visitor.visit_some(&mut *self),
-            v => Err(ErrorKind::InvalidTagEncoding(v as usize).into())
+            v => Err(ErrorKind::InvalidTagEncoding(v as usize).into()),
         }
     }
 
     fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value>
-        where V: serde::de::Visitor<'de>,
+    where
+        V: serde::de::Visitor<'de>,
     {
         let len = try!(serde::Deserialize::deserialize(&mut *self));
 
@@ -260,22 +296,34 @@ where R: BincodeRead<'de>, S: SizeLimit, E: ByteOrder {
     }
 
     fn deserialize_map<V>(self, visitor: V) -> Result<V::Value>
-        where V: serde::de::Visitor<'de>,
+    where
+        V: serde::de::Visitor<'de>,
     {
         struct Access<'a, R: Read + 'a, S: SizeLimit + 'a, E: ByteOrder + 'a> {
             deserializer: &'a mut Deserializer<R, S, E>,
             len: usize,
         }
 
-        impl<'de, 'a, 'b: 'a, R: BincodeRead<'de> + 'b, S: SizeLimit, E: ByteOrder> serde::de::MapAccess<'de> for Access<'a, R, S, E> {
+        impl<
+            'de,
+            'a,
+            'b: 'a,
+            R: BincodeRead<'de> + 'b,
+            S: SizeLimit,
+            E: ByteOrder,
+        > serde::de::MapAccess<'de> for Access<'a, R, S, E> {
             type Error = Error;
 
             fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
-                where K: serde::de::DeserializeSeed<'de>,
+            where
+                K: serde::de::DeserializeSeed<'de>,
             {
                 if self.len > 0 {
                     self.len -= 1;
-                    let key = try!(serde::de::DeserializeSeed::deserialize(seed, &mut *self.deserializer));
+                    let key = try!(serde::de::DeserializeSeed::deserialize(
+                        seed,
+                        &mut *self.deserializer,
+                    ));
                     Ok(Some(key))
                 } else {
                     Ok(None)
@@ -283,9 +331,13 @@ where R: BincodeRead<'de>, S: SizeLimit, E: ByteOrder {
             }
 
             fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
-                where V: serde::de::DeserializeSeed<'de>,
+            where
+                V: serde::de::DeserializeSeed<'de>,
             {
-                let value = try!(serde::de::DeserializeSeed::deserialize(seed, &mut *self.deserializer));
+                let value = try!(serde::de::DeserializeSeed::deserialize(
+                    seed,
+                    &mut *self.deserializer,
+                ));
                 Ok(value)
             }
 
@@ -296,54 +348,61 @@ where R: BincodeRead<'de>, S: SizeLimit, E: ByteOrder {
 
         let len = try!(serde::Deserialize::deserialize(&mut *self));
 
-        visitor.visit_map(Access { deserializer: self, len: len })
+        visitor.visit_map(Access {
+            deserializer: self,
+            len: len,
+        })
     }
 
-    fn deserialize_struct<V>(self,
+    fn deserialize_struct<V>(
-                       _name: &str,
+        self,
-                       fields: &'static [&'static str],
+        _name: &str,
-                       visitor: V) -> Result<V::Value>
+        fields: &'static [&'static str],
-        where V: serde::de::Visitor<'de>,
+        visitor: V,
+    ) -> Result<V::Value>
+    where
+        V: serde::de::Visitor<'de>,
     {
         self.deserialize_tuple(fields.len(), visitor)
     }
 
-    fn deserialize_identifier<V>(self,
+    fn deserialize_identifier<V>(self, _visitor: V) -> Result<V::Value>
-                                   _visitor: V) -> Result<V::Value>
+    where
-        where V: serde::de::Visitor<'de>,
+        V: serde::de::Visitor<'de>,
     {
         let message = "bincode does not support Deserializer::deserialize_identifier";
         Err(Error::custom(message))
     }
 
-    fn deserialize_newtype_struct<V>(self,
+    fn deserialize_newtype_struct<V>(self, _name: &str, visitor: V) -> Result<V::Value>
-                               _name: &str,
+    where
-                               visitor: V) -> Result<V::Value>
+        V: serde::de::Visitor<'de>,
-        where V: serde::de::Visitor<'de>,
     {
         visitor.visit_newtype_struct(self)
     }
 
-    fn deserialize_unit_struct<V>(self,
+    fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
-                                  _name: &'static str,
+    where
-                                  visitor: V) -> Result<V::Value>
+        V: serde::de::Visitor<'de>,
-        where V: serde::de::Visitor<'de>,
     {
         visitor.visit_unit()
     }
 
-    fn deserialize_tuple_struct<V>(self,
+    fn deserialize_tuple_struct<V>(
-                                   _name: &'static str,
+        self,
-                                   len: usize,
+        _name: &'static str,
-                                   visitor: V) -> Result<V::Value>
+        len: usize,
-        where V: serde::de::Visitor<'de>,
+        visitor: V,
+    ) -> Result<V::Value>
+    where
+        V: serde::de::Visitor<'de>,
     {
         self.deserialize_tuple(len, visitor)
     }
 
-    fn deserialize_ignored_any<V>(self,
+    fn deserialize_ignored_any<V>(self, _visitor: V) -> Result<V::Value>
-                                  _visitor: V) -> Result<V::Value>
+    where
-        where V: serde::de::Visitor<'de>,
+        V: serde::de::Visitor<'de>,
     {
         let message = "bincode does not support Deserializer::deserialize_ignored_any";
         Err(Error::custom(message))

src/de/read.rs

@@ -1,25 +1,27 @@
 use std::io;
-use ::Result;
+use Result;
 use serde_crate as serde;
 
 /// A byte-oriented reading trait that is specialized for
 /// slices and generic readers.
 pub trait BincodeRead<'storage>: io::Read + ::private::Sealed {
     #[doc(hidden)]
-    fn forward_read_str<V>(&mut self, length: usize, visitor: V) ->  Result<V::Value>
+    fn forward_read_str<V>(&mut self, length: usize, visitor: V) -> Result<V::Value>
-    where V: serde::de::Visitor<'storage>;
+    where
+        V: serde::de::Visitor<'storage>;
 
     #[doc(hidden)]
     fn get_byte_buffer(&mut self, length: usize) -> Result<Vec<u8>>;
 
     #[doc(hidden)]
-    fn forward_read_bytes<V>(&mut self, length: usize, visitor: V) ->  Result<V::Value>
+    fn forward_read_bytes<V>(&mut self, length: usize, visitor: V) -> Result<V::Value>
-    where V: serde::de::Visitor<'storage>;
+    where
+        V: serde::de::Visitor<'storage>;
 }
 
 /// A BincodeRead implementation for byte slices
 pub struct SliceReader<'storage> {
-    slice: &'storage [u8]
+    slice: &'storage [u8],
 }
 
 /// A BincodeRead implementation for io::Readers
@@ -28,16 +30,14 @@ pub struct IoReader<R> {
     temp_buffer: Vec<u8>,
 }
 
-impl <'storage> SliceReader<'storage> {
+impl<'storage> SliceReader<'storage> {
     /// Constructs a slice reader
     pub fn new(bytes: &'storage [u8]) -> SliceReader<'storage> {
-        SliceReader {
+        SliceReader { slice: bytes }
-            slice: bytes,
-        }
     }
 }
 
-impl <R> IoReader<R> {
+impl<R> IoReader<R> {
     /// Constructs an IoReadReader
     pub fn new(r: R) -> IoReader<R> {
         IoReader {
@@ -47,34 +47,38 @@ impl <R> IoReader<R> {
     }
 }
 
-impl <'storage> io::Read for SliceReader<'storage> {
+impl<'storage> io::Read for SliceReader<'storage> {
-    fn read(&mut self, out: & mut [u8]) -> io::Result<usize> {
+    fn read(&mut self, out: &mut [u8]) -> io::Result<usize> {
         (&mut self.slice).read(out)
     }
-    fn read_exact(&mut self, out: & mut [u8]) -> io::Result<()> {
+    fn read_exact(&mut self, out: &mut [u8]) -> io::Result<()> {
         (&mut self.slice).read_exact(out)
     }
 }
 
-impl <R: io::Read> io::Read for IoReader<R> {
+impl<R: io::Read> io::Read for IoReader<R> {
-    fn read(&mut self, out: & mut [u8]) -> io::Result<usize> {
+    fn read(&mut self, out: &mut [u8]) -> io::Result<usize> {
         self.reader.read(out)
     }
-    fn read_exact(&mut self, out: & mut [u8]) -> io::Result<()> {
+    fn read_exact(&mut self, out: &mut [u8]) -> io::Result<()> {
         self.reader.read_exact(out)
     }
 }
 
-impl <'storage> SliceReader<'storage> {
+impl<'storage> SliceReader<'storage> {
     fn unexpected_eof() -> Box<::ErrorKind> {
-        return Box::new(::ErrorKind::Io(io::Error::new(io::ErrorKind::UnexpectedEof, "")));
+        return Box::new(::ErrorKind::Io(
+            io::Error::new(io::ErrorKind::UnexpectedEof, ""),
+        ));
     }
 }
 
-impl <'storage> BincodeRead<'storage> for SliceReader<'storage> {
+impl<'storage> BincodeRead<'storage> for SliceReader<'storage> {
-    fn forward_read_str<V>(&mut self, length: usize, visitor: V) ->  Result<V::Value>
+    fn forward_read_str<V>(&mut self, length: usize, visitor: V) -> Result<V::Value>
-    where V: serde::de::Visitor<'storage> {
+    where
-        use ::ErrorKind;
+        V: serde::de::Visitor<'storage>,
+    {
+        use ErrorKind;
         if length > self.slice.len() {
             return Err(SliceReader::unexpected_eof());
         }
@@ -98,8 +102,10 @@ impl <'storage> BincodeRead<'storage> for SliceReader<'storage> {
         Ok(r.to_vec())
     }
 
-    fn forward_read_bytes<V>(&mut self, length: usize, visitor: V) ->  Result<V::Value>
+    fn forward_read_bytes<V>(&mut self, length: usize, visitor: V) -> Result<V::Value>
-    where V: serde::de::Visitor<'storage> {
+    where
+        V: serde::de::Visitor<'storage>,
+    {
         if length > self.slice.len() {
             return Err(SliceReader::unexpected_eof());
         }
@@ -110,12 +116,17 @@ impl <'storage> BincodeRead<'storage> for SliceReader<'storage> {
     }
 }
 
-impl <R> IoReader<R> where R: io::Read {
+impl<R> IoReader<R>
+where
+    R: io::Read,
+{
     fn fill_buffer(&mut self, length: usize) -> Result<()> {
         let current_length = self.temp_buffer.len();
-        if length > current_length{
+        if length > current_length {
             self.temp_buffer.reserve_exact(length - current_length);
-            unsafe { self.temp_buffer.set_len(length); }
+            unsafe {
+                self.temp_buffer.set_len(length);
+            }
         }
 
         self.reader.read_exact(&mut self.temp_buffer[..length])?;
@@ -123,9 +134,14 @@ impl <R> IoReader<R> where R: io::Read {
     }
 }
 
-impl <R> BincodeRead<'static> for IoReader<R> where R: io::Read {
+impl<R> BincodeRead<'static> for IoReader<R>
-    fn forward_read_str<V>(&mut self, length: usize, visitor: V) ->  Result<V::Value>
+where
-    where V: serde::de::Visitor<'static> {
+    R: io::Read,
+{
+    fn forward_read_str<V>(&mut self, length: usize, visitor: V) -> Result<V::Value>
+    where
+        V: serde::de::Visitor<'static>,
+    {
         self.fill_buffer(length)?;
 
         let string = match ::std::str::from_utf8(&self.temp_buffer[..length]) {
@@ -142,8 +158,10 @@ impl <R> BincodeRead<'static> for IoReader<R> where R: io::Read {
         Ok(self.temp_buffer[..length].to_vec())
     }
 
-    fn forward_read_bytes<V>(&mut self, length: usize, visitor: V) ->  Result<V::Value>
+    fn forward_read_bytes<V>(&mut self, length: usize, visitor: V) -> Result<V::Value>
-    where V: serde::de::Visitor<'static> {
+    where
+        V: serde::de::Visitor<'static>,
+    {
         self.fill_buffer(length)?;
         let r = visitor.visit_bytes(&self.temp_buffer[..length]);
         r

src/internal.rs

@@ -5,17 +5,13 @@
 use std::io::{self, Write, Read};
 use std::{error, fmt, result};
 use std::str::Utf8Error;
-use ::{CountSize, SizeLimit};
+use {CountSize, SizeLimit};
-use byteorder::{ByteOrder};
+use byteorder::ByteOrder;
 use std::error::Error as StdError;
 
-pub use super::de::{
+pub use super::de::Deserializer;
-    Deserializer,
-};
 
-pub use super::ser::{
+pub use super::ser::Serializer;
-    Serializer,
-};
 
 use super::ser::SizeChecker;
 
@@ -52,7 +48,7 @@ pub enum ErrorKind {
     /// Bincode can not encode sequences of unknown length (like iterators).
     SequenceMustHaveLength,
     /// A custom error message from Serde.
-    Custom(String)
+    Custom(String),
 }
 
 impl StdError for ErrorKind {
@@ -64,7 +60,9 @@ impl StdError for ErrorKind {
             ErrorKind::InvalidCharEncoding => "char is not valid",
             ErrorKind::InvalidTagEncoding(_) => "tag for enum is not valid",
             ErrorKind::SequenceMustHaveLength => "bincode can't encode infinite sequences",
-            ErrorKind::DeserializeAnyNotSupported => "bincode doesn't support serde::Deserializer::deserialize_any",
+            ErrorKind::DeserializeAnyNotSupported => {
+                "bincode doesn't support serde::Deserializer::deserialize_any"
+            }
             ErrorKind::SizeLimit => "the size limit for decoding has been reached",
             ErrorKind::Custom(ref msg) => msg,
 
@@ -95,24 +93,29 @@ impl From<io::Error> for Error {
 impl fmt::Display for ErrorKind {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         match *self {
-            ErrorKind::Io(ref ioerr) =>
+            ErrorKind::Io(ref ioerr) => write!(fmt, "io error: {}", ioerr),
-                write!(fmt, "io error: {}", ioerr),
+            ErrorKind::InvalidUtf8Encoding(ref e) => write!(fmt, "{}: {}", self.description(), e),
-            ErrorKind::InvalidUtf8Encoding(ref e) =>
+            ErrorKind::InvalidBoolEncoding(b) => {
-                write!(fmt, "{}: {}", self.description(), e),
+                write!(fmt, "{}, expected 0 or 1, found {}", self.description(), b)
-            ErrorKind::InvalidBoolEncoding(b) =>
+            }
-                write!(fmt, "{}, expected 0 or 1, found {}", self.description(), b),
+            ErrorKind::InvalidCharEncoding => write!(fmt, "{}", self.description()),
-            ErrorKind::InvalidCharEncoding =>
+            ErrorKind::InvalidTagEncoding(tag) => {
-                write!(fmt, "{}", self.description()),
+                write!(fmt, "{}, found {}", self.description(), tag)
-            ErrorKind::InvalidTagEncoding(tag) =>
+            }
-                write!(fmt, "{}, found {}", self.description(), tag),
+            ErrorKind::SequenceMustHaveLength => {
-            ErrorKind::SequenceMustHaveLength =>
+                write!(
-                write!(fmt, "bincode can only encode sequences and maps that have a knowable size ahead of time."),
+                    fmt,
-            ErrorKind::SizeLimit =>
+                    "bincode can only encode sequences and maps that have a knowable size ahead of time."
-                write!(fmt, "size limit was exceeded"),
+                )
-            ErrorKind::DeserializeAnyNotSupported=>
+            }
-                write!(fmt, "bincode does not support the serde::Deserializer::deserialize_any method"),
+            ErrorKind::SizeLimit => write!(fmt, "size limit was exceeded"),
-            ErrorKind::Custom(ref s) =>
+            ErrorKind::DeserializeAnyNotSupported => {
-                s.fmt(fmt),
+                write!(
+                    fmt,
+                    "bincode does not support the serde::Deserializer::deserialize_any method"
+                )
+            }
+            ErrorKind::Custom(ref s) => s.fmt(fmt),
         }
     }
 }
@@ -138,10 +141,16 @@ impl serde::ser::Error for Error {
 /// writer is in an invalid state, as writing could bail out in the middle of
 /// serializing.
 pub fn serialize_into<W, T: ?Sized, S, E>(writer: W, value: &T, size_limit: S) -> Result<()>
-    where W: Write, T: serde::Serialize, S: SizeLimit, E: ByteOrder
+where
+    W: Write,
+    T: serde::Serialize,
+    S: SizeLimit,
+    E: ByteOrder,
 {
     if let Some(limit) = size_limit.limit() {
-        try!(serialized_size_bounded(value, limit).ok_or(ErrorKind::SizeLimit));
+        try!(serialized_size_bounded(value, limit).ok_or(
+            ErrorKind::SizeLimit,
+        ));
     }
 
     let mut serializer = Serializer::<_, E>::new(writer);
@@ -153,11 +162,16 @@ pub fn serialize_into<W, T: ?Sized, S, E>(writer: W, value: &T, size_limit: S) -
 /// If the serialization would take more bytes than allowed by `size_limit`,
 /// an error is returned.
 pub fn serialize<T: ?Sized, S, E>(value: &T, size_limit: S) -> Result<Vec<u8>>
-    where T: serde::Serialize, S: SizeLimit, E: ByteOrder
+where
+    T: serde::Serialize,
+    S: SizeLimit,
+    E: ByteOrder,
 {
     let mut writer = match size_limit.limit() {
         Some(size_limit) => {
-            let actual_size = try!(serialized_size_bounded(value, size_limit).ok_or(ErrorKind::SizeLimit));
+            let actual_size = try!(serialized_size_bounded(value, size_limit).ok_or(
+                ErrorKind::SizeLimit,
+            ));
             Vec::with_capacity(actual_size as usize)
         }
         None => {
@@ -166,7 +180,11 @@ pub fn serialize<T: ?Sized, S, E>(value: &T, size_limit: S) -> Result<Vec<u8>>
         }
     };
 
-    try!(serialize_into::<_, _, _, E>(&mut writer, value, super::Infinite));
+    try!(serialize_into::<_, _, _, E>(
+        &mut writer,
+        value,
+        super::Infinite,
+    ));
     Ok(writer)
 }
 
@@ -175,7 +193,7 @@ impl SizeLimit for CountSize {
         self.total += c;
         if let Some(limit) = self.limit {
             if self.total > limit {
-                return Err(Box::new(ErrorKind::SizeLimit))
+                return Err(Box::new(ErrorKind::SizeLimit));
             }
         }
         Ok(())
@@ -191,10 +209,14 @@ impl SizeLimit for CountSize {
 /// This is used internally as part of the check for encode_into, but it can
 /// be useful for preallocating buffers if thats your style.
 pub fn serialized_size<T: ?Sized>(value: &T) -> u64
-    where T: serde::Serialize
+where
+    T: serde::Serialize,
 {
     let mut size_counter = SizeChecker {
-        size_limit: CountSize { total: 0, limit: None }
+        size_limit: CountSize {
+            total: 0,
+            limit: None,
+        },
     };
 
     value.serialize(&mut size_counter).ok();
@@ -207,10 +229,14 @@ pub fn serialized_size<T: ?Sized>(value: &T) -> u64
 /// If it can be serialized in `max` or fewer bytes, that number will be returned
 /// inside `Some`.  If it goes over bounds, then None is returned.
 pub fn serialized_size_bounded<T: ?Sized>(value: &T, max: u64) -> Option<u64>
-    where T: serde::Serialize
+where
+    T: serde::Serialize,
 {
     let mut size_counter = SizeChecker {
-        size_limit: CountSize { total: 0, limit: Some(max) }
+        size_limit: CountSize {
+            total: 0,
+            limit: Some(max),
+        },
     };
 
     match value.serialize(&mut size_counter) {
@@ -229,7 +255,11 @@ pub fn serialized_size_bounded<T: ?Sized>(value: &T, max: u64) -> Option<u64>
 /// in is in an invalid state, as the error could be returned during any point
 /// in the reading.
 pub fn deserialize_from<R, T, S, E>(reader: R, size_limit: S) -> Result<T>
-    where R: Read, T: serde::de::DeserializeOwned, S: SizeLimit, E: ByteOrder
+where
+    R: Read,
+    T: serde::de::DeserializeOwned,
+    S: SizeLimit,
+    E: ByteOrder,
 {
     let reader = ::de::read::IoReader::new(reader);
     let mut deserializer = Deserializer::<_, S, E>::new(reader, size_limit);
@@ -241,7 +271,8 @@ pub fn deserialize_from<R, T, S, E>(reader: R, size_limit: S) -> Result<T>
 /// This method does not have a size-limit because if you already have the bytes
 /// in memory, then you don't gain anything by having a limiter.
 pub fn deserialize<'a, T, E: ByteOrder>(bytes: &'a [u8]) -> Result<T>
-    where T: serde::de::Deserialize<'a>,
+where
+    T: serde::de::Deserialize<'a>,
 {
     let reader = ::de::read::SliceReader::new(bytes);
     let mut deserializer = Deserializer::<_, _, E>::new(reader, super::Infinite);

src/lib.rs

@@ -45,7 +45,7 @@ pub mod internal;
 
 pub mod read_types {
     //! The types that the deserializer uses for optimizations
-    pub use ::de::read::{SliceReader, BincodeRead, IoReader};
+    pub use de::read::{SliceReader, BincodeRead, IoReader};
 }
 
 use std::io::{Read, Write};
@@ -62,7 +62,8 @@ pub type Serializer<W> = internal::Serializer<W, byteorder::LittleEndian>;
 /// This method does not have a size-limit because if you already have the bytes
 /// in memory, then you don't gain anything by having a limiter.
 pub fn deserialize<'a, T>(bytes: &'a [u8]) -> internal::Result<T>
-    where T: serde_crate::de::Deserialize<'a>,
+where
+    T: serde_crate::de::Deserialize<'a>,
 {
     internal::deserialize::<_, byteorder::LittleEndian>(bytes)
 }
@@ -77,7 +78,10 @@ pub fn deserialize<'a, T>(bytes: &'a [u8]) -> internal::Result<T>
 /// in is in an invalid state, as the error could be returned during any point
 /// in the reading.
 pub fn deserialize_from<R: ?Sized, T, S>(reader: &mut R, size_limit: S) -> internal::Result<T>
-    where R: Read, T: serde_crate::de::DeserializeOwned, S: SizeLimit
+where
+    R: Read,
+    T: serde_crate::de::DeserializeOwned,
+    S: SizeLimit,
 {
     internal::deserialize_from::<_, _, _, byteorder::LittleEndian>(reader, size_limit)
 }
@@ -90,8 +94,15 @@ pub fn deserialize_from<R: ?Sized, T, S>(reader: &mut R, size_limit: S) -> inter
 /// If this returns an `Error` (other than SizeLimit), assume that the
 /// writer is in an invalid state, as writing could bail out in the middle of
 /// serializing.
-pub fn serialize_into<W: ?Sized, T: ?Sized, S>(writer: &mut W, value: &T, size_limit: S) -> internal::Result<()>
+pub fn serialize_into<W: ?Sized, T: ?Sized, S>(
-    where W: Write, T: serde_crate::Serialize, S: SizeLimit
+    writer: &mut W,
+    value: &T,
+    size_limit: S,
+) -> internal::Result<()>
+where
+    W: Write,
+    T: serde_crate::Serialize,
+    S: SizeLimit,
 {
     internal::serialize_into::<_, _, _, byteorder::LittleEndian>(writer, value, size_limit)
 }
@@ -101,7 +112,9 @@ pub fn serialize_into<W: ?Sized, T: ?Sized, S>(writer: &mut W, value: &T, size_l
 /// If the serialization would take more bytes than allowed by `size_limit`,
 /// an error is returned.
 pub fn serialize<T: ?Sized, S>(value: &T, size_limit: S) -> internal::Result<Vec<u8>>
-    where T: serde_crate::Serialize, S: SizeLimit
+where
+    T: serde_crate::Serialize,
+    S: SizeLimit,
 {
     internal::serialize::<_, _, byteorder::LittleEndian>(value, size_limit)
 }
@@ -159,15 +172,21 @@ impl SizeLimit for Bounded {
     }
 
     #[inline(always)]
-    fn limit(&self) -> Option<u64> { Some(self.0) }
+    fn limit(&self) -> Option<u64> {
+        Some(self.0)
+    }
 }
 
 impl SizeLimit for Infinite {
     #[inline(always)]
-    fn add(&mut self, _: u64) -> Result<()> { Ok (()) }
+    fn add(&mut self, _: u64) -> Result<()> {
+        Ok(())
+    }
 
     #[inline(always)]
-    fn limit(&self) -> Option<u64> { None }
+    fn limit(&self) -> Option<u64> {
+        None
+    }
 }
 
 mod private {

src/ser/mod.rs

@@ -42,12 +42,18 @@ impl<'a, W: Write, E: ByteOrder> serde::Serializer for &'a mut Serializer<W, E>
     type SerializeStruct = Compound<'a, W, E>;
     type SerializeStructVariant = Compound<'a, W, E>;
 
-    fn serialize_unit(self) -> Result<()> { Ok(()) }
+    fn serialize_unit(self) -> Result<()> {
+        Ok(())
+    }
 
-    fn serialize_unit_struct(self, _: &'static str) -> Result<()> { Ok(()) }
+    fn serialize_unit_struct(self, _: &'static str) -> Result<()> {
+        Ok(())
+    }
 
     fn serialize_bool(self, v: bool) -> Result<()> {
-        self.writer.write_u8(if v {1} else {0}).map_err(Into::into)
+        self.writer.write_u8(if v { 1 } else { 0 }).map_err(
+            Into::into,
+        )
     }
 
     fn serialize_u8(self, v: u8) -> Result<()> {
@@ -96,7 +102,9 @@ impl<'a, W: Write, E: ByteOrder> serde::Serializer for &'a mut Serializer<W, E>
     }
 
     fn serialize_char(self, c: char) -> Result<()> {
-        self.writer.write_all(encode_utf8(c).as_slice()).map_err(Into::into)
+        self.writer.write_all(encode_utf8(c).as_slice()).map_err(
+            Into::into,
+        )
     }
 
     fn serialize_bytes(self, v: &[u8]) -> Result<()> {
@@ -109,7 +117,8 @@ impl<'a, W: Write, E: ByteOrder> serde::Serializer for &'a mut Serializer<W, E>
     }
 
     fn serialize_some<T: ?Sized>(self, v: &T) -> Result<()>
-        where T: serde::Serialize,
+    where
+        T: serde::Serialize,
     {
         try!(self.writer.write_u8(1));
         v.serialize(self)
@@ -118,70 +127,80 @@ impl<'a, W: Write, E: ByteOrder> serde::Serializer for &'a mut Serializer<W, E>
     fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
         let len = try!(len.ok_or(ErrorKind::SequenceMustHaveLength));
         try!(self.serialize_u64(len as u64));
-        Ok(Compound {ser: self})
+        Ok(Compound { ser: self })
     }
 
     fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
-        Ok(Compound {ser: self})
+        Ok(Compound { ser: self })
     }
 
-    fn serialize_tuple_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeTupleStruct> {
+    fn serialize_tuple_struct(
-        Ok(Compound {ser: self})
+        self,
+        _name: &'static str,
+        _len: usize,
+    ) -> Result<Self::SerializeTupleStruct> {
+        Ok(Compound { ser: self })
     }
 
-    fn serialize_tuple_variant(self,
+    fn serialize_tuple_variant(
-                              _name: &'static str,
+        self,
-                              variant_index: u32,
+        _name: &'static str,
-                              _variant: &'static str,
+        variant_index: u32,
-                              _len: usize) -> Result<Self::SerializeTupleVariant>
+        _variant: &'static str,
-    {
+        _len: usize,
+    ) -> Result<Self::SerializeTupleVariant> {
         try!(self.serialize_u32(variant_index));
-        Ok(Compound {ser: self})
+        Ok(Compound { ser: self })
     }
 
     fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> {
         let len = try!(len.ok_or(ErrorKind::SequenceMustHaveLength));
         try!(self.serialize_u64(len as u64));
-        Ok(Compound {ser: self})
+        Ok(Compound { ser: self })
     }
 
     fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct> {
-        Ok(Compound {ser: self})
+        Ok(Compound { ser: self })
     }
 
-    fn serialize_struct_variant(self,
+    fn serialize_struct_variant(
-                               _name: &'static str,
+        self,
-                               variant_index: u32,
+        _name: &'static str,
-                               _variant: &'static str,
+        variant_index: u32,
-                               _len: usize) -> Result<Self::SerializeStructVariant>
+        _variant: &'static str,
-    {
+        _len: usize,
+    ) -> Result<Self::SerializeStructVariant> {
         try!(self.serialize_u32(variant_index));
-        Ok(Compound {ser: self})
+        Ok(Compound { ser: self })
     }
 
-    fn serialize_newtype_struct<T: ?Sized>(self,
+    fn serialize_newtype_struct<T: ?Sized>(self, _name: &'static str, value: &T) -> Result<()>
-                               _name: &'static str,
+    where
-                               value: &T) -> Result<()>
+        T: serde::ser::Serialize,
-        where T: serde::ser::Serialize,
     {
         value.serialize(self)
     }
 
-    fn serialize_newtype_variant<T: ?Sized>(self,
+    fn serialize_newtype_variant<T: ?Sized>(
-                               _name: &'static str,
+        self,
-                               variant_index: u32,
+        _name: &'static str,
-                               _variant: &'static str,
+        variant_index: u32,
-                               value: &T) -> Result<()>
+        _variant: &'static str,
-        where T: serde::ser::Serialize,
+        value: &T,
+    ) -> Result<()>
+    where
+        T: serde::ser::Serialize,
     {
         try!(self.serialize_u32(variant_index));
         value.serialize(self)
     }
 
-    fn serialize_unit_variant(self,
+    fn serialize_unit_variant(
-                          _name: &'static str,
+        self,
-                          variant_index: u32,
+        _name: &'static str,
-                          _variant: &'static str) -> Result<()> {
+        variant_index: u32,
+        _variant: &'static str,
+    ) -> Result<()> {
         self.serialize_u32(variant_index)
     }
 }
@@ -190,11 +209,9 @@ pub struct SizeChecker<S: SizeLimit> {
     pub size_limit: S,
 }
 
-impl <S: SizeLimit> SizeChecker<S> {
+impl<S: SizeLimit> SizeChecker<S> {
     pub fn new(size_limit: S) -> SizeChecker<S> {
-        SizeChecker {
+        SizeChecker { size_limit: size_limit }
-            size_limit: size_limit
-        }
     }
 
     fn add_raw(&mut self, size: u64) -> Result<()> {
@@ -218,9 +235,13 @@ impl<'a, S: SizeLimit> serde::Serializer for &'a mut SizeChecker<S> {
     type SerializeStruct = SizeCompound<'a, S>;
     type SerializeStructVariant = SizeCompound<'a, S>;
 
-    fn serialize_unit(self) -> Result<()> { Ok(()) }
+    fn serialize_unit(self) -> Result<()> {
+        Ok(())
+    }
 
-    fn serialize_unit_struct(self, _: &'static str) -> Result<()> { Ok(()) }
+    fn serialize_unit_struct(self, _: &'static str) -> Result<()> {
+        Ok(())
+    }
 
     fn serialize_bool(self, _: bool) -> Result<()> {
         self.add_value(0 as u8)
@@ -285,7 +306,8 @@ impl<'a, S: SizeLimit> serde::Serializer for &'a mut SizeChecker<S> {
     }
 
     fn serialize_some<T: ?Sized>(self, v: &T) -> Result<()>
-        where T: serde::Serialize,
+    where
+        T: serde::Serialize,
     {
         try!(self.add_value(1 as u8));
         v.serialize(self)
@@ -295,66 +317,78 @@ impl<'a, S: SizeLimit> serde::Serializer for &'a mut SizeChecker<S> {
         let len = try!(len.ok_or(ErrorKind::SequenceMustHaveLength));
 
         try!(self.serialize_u64(len as u64));
-        Ok(SizeCompound {ser: self})
+        Ok(SizeCompound { ser: self })
     }
 
     fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
-        Ok(SizeCompound {ser: self})
+        Ok(SizeCompound { ser: self })
     }
 
-    fn serialize_tuple_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeTupleStruct> {
+    fn serialize_tuple_struct(
-        Ok(SizeCompound {ser: self})
+        self,
+        _name: &'static str,
+        _len: usize,
+    ) -> Result<Self::SerializeTupleStruct> {
+        Ok(SizeCompound { ser: self })
     }
 
-    fn serialize_tuple_variant(self,
+    fn serialize_tuple_variant(
-                         _name: &'static str,
+        self,
-                         variant_index: u32,
+        _name: &'static str,
-                         _variant: &'static str,
+        variant_index: u32,
-                         _len: usize) -> Result<Self::SerializeTupleVariant>
+        _variant: &'static str,
-    {
+        _len: usize,
+    ) -> Result<Self::SerializeTupleVariant> {
         try!(self.add_value(variant_index));
-        Ok(SizeCompound {ser: self})
+        Ok(SizeCompound { ser: self })
     }
 
-    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap>
+    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> {
-    {
         let len = try!(len.ok_or(ErrorKind::SequenceMustHaveLength));
 
         try!(self.serialize_u64(len as u64));
-        Ok(SizeCompound {ser: self})
+        Ok(SizeCompound { ser: self })
     }
 
     fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct> {
-        Ok(SizeCompound {ser: self})
+        Ok(SizeCompound { ser: self })
     }
 
-    fn serialize_struct_variant(self,
+    fn serialize_struct_variant(
-                               _name: &'static str,
+        self,
-                               variant_index: u32,
+        _name: &'static str,
-                               _variant: &'static str,
+        variant_index: u32,
-                               _len: usize) -> Result<Self::SerializeStructVariant>
+        _variant: &'static str,
-    {
+        _len: usize,
+    ) -> Result<Self::SerializeStructVariant> {
         try!(self.add_value(variant_index));
-        Ok(SizeCompound {ser: self})
+        Ok(SizeCompound { ser: self })
     }
 
-    fn serialize_newtype_struct<V: serde::Serialize + ?Sized>(self, _name: &'static str, v: &V) -> Result<()> {
+    fn serialize_newtype_struct<V: serde::Serialize + ?Sized>(
+        self,
+        _name: &'static str,
+        v: &V,
+    ) -> Result<()> {
         v.serialize(self)
     }
 
-    fn serialize_unit_variant(self,
+    fn serialize_unit_variant(
-                          _name: &'static str,
+        self,
-                          variant_index: u32,
+        _name: &'static str,
-                          _variant: &'static str) -> Result<()> {
+        variant_index: u32,
+        _variant: &'static str,
+    ) -> Result<()> {
         self.add_value(variant_index)
     }
 
-    fn serialize_newtype_variant<V: serde::Serialize + ?Sized>(self,
+    fn serialize_newtype_variant<V: serde::Serialize + ?Sized>(
-                               _name: &'static str,
+        self,
-                               variant_index: u32,
+        _name: &'static str,
-                               _variant: &'static str,
+        variant_index: u32,
-                               value: &V) -> Result<()>
+        _variant: &'static str,
-    {
+        value: &V,
+    ) -> Result<()> {
         try!(self.add_value(variant_index));
         value.serialize(self)
     }
@@ -366,14 +400,17 @@ pub struct Compound<'a, W: 'a, E: ByteOrder + 'a> {
 }
 
 impl<'a, W, E> serde::ser::SerializeSeq for Compound<'a, W, E>
-    where W: Write, E: ByteOrder
+where
+    W: Write,
+    E: ByteOrder,
 {
     type Ok = ();
     type Error = Error;
 
     #[inline]
     fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<()>
-    where T: serde::ser::Serialize
+    where
+        T: serde::ser::Serialize,
     {
         value.serialize(&mut *self.ser)
     }
@@ -385,14 +422,17 @@ impl<'a, W, E> serde::ser::SerializeSeq for Compound<'a, W, E>
 }
 
 impl<'a, W, E> serde::ser::SerializeTuple for Compound<'a, W, E>
-    where W: Write, E: ByteOrder
+where
+    W: Write,
+    E: ByteOrder,
 {
     type Ok = ();
     type Error = Error;
 
     #[inline]
     fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<()>
-    where T: serde::ser::Serialize
+    where
+        T: serde::ser::Serialize,
     {
         value.serialize(&mut *self.ser)
     }
@@ -404,14 +444,17 @@ impl<'a, W, E> serde::ser::SerializeTuple for Compound<'a, W, E>
 }
 
 impl<'a, W, E> serde::ser::SerializeTupleStruct for Compound<'a, W, E>
-    where W: Write, E: ByteOrder
+where
+    W: Write,
+    E: ByteOrder,
 {
     type Ok = ();
     type Error = Error;
 
     #[inline]
     fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<()>
-    where T: serde::ser::Serialize
+    where
+        T: serde::ser::Serialize,
     {
         value.serialize(&mut *self.ser)
     }
@@ -423,14 +466,17 @@ impl<'a, W, E> serde::ser::SerializeTupleStruct for Compound<'a, W, E>
 }
 
 impl<'a, W, E> serde::ser::SerializeTupleVariant for Compound<'a, W, E>
-    where W: Write, E: ByteOrder
+where
+    W: Write,
+    E: ByteOrder,
 {
     type Ok = ();
     type Error = Error;
 
     #[inline]
     fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<()>
-    where T: serde::ser::Serialize
+    where
+        T: serde::ser::Serialize,
     {
         value.serialize(&mut *self.ser)
     }
@@ -442,21 +488,25 @@ impl<'a, W, E> serde::ser::SerializeTupleVariant for Compound<'a, W, E>
 }
 
 impl<'a, W, E> serde::ser::SerializeMap for Compound<'a, W, E>
-    where W: Write, E: ByteOrder
+where
+    W: Write,
+    E: ByteOrder,
 {
     type Ok = ();
     type Error = Error;
 
     #[inline]
     fn serialize_key<K: ?Sized>(&mut self, value: &K) -> Result<()>
-    where K: serde::ser::Serialize
+    where
+        K: serde::ser::Serialize,
     {
         value.serialize(&mut *self.ser)
     }
 
-        #[inline]
+    #[inline]
     fn serialize_value<V: ?Sized>(&mut self, value: &V) -> Result<()>
-    where V: serde::ser::Serialize
+    where
+        V: serde::ser::Serialize,
     {
         value.serialize(&mut *self.ser)
     }
@@ -468,14 +518,17 @@ impl<'a, W, E> serde::ser::SerializeMap for Compound<'a, W, E>
 }
 
 impl<'a, W, E> serde::ser::SerializeStruct for Compound<'a, W, E>
-    where W: Write, E: ByteOrder
+where
+    W: Write,
+    E: ByteOrder,
 {
     type Ok = ();
     type Error = Error;
 
     #[inline]
     fn serialize_field<T: ?Sized>(&mut self, _key: &'static str, value: &T) -> Result<()>
-    where T: serde::ser::Serialize
+    where
+        T: serde::ser::Serialize,
     {
         value.serialize(&mut *self.ser)
     }
@@ -487,14 +540,17 @@ impl<'a, W, E> serde::ser::SerializeStruct for Compound<'a, W, E>
 }
 
 impl<'a, W, E> serde::ser::SerializeStructVariant for Compound<'a, W, E>
-    where W: Write, E: ByteOrder
+where
+    W: Write,
+    E: ByteOrder,
 {
     type Ok = ();
     type Error = Error;
 
     #[inline]
     fn serialize_field<T: ?Sized>(&mut self, _key: &'static str, value: &T) -> Result<()>
-    where T: serde::ser::Serialize
+    where
+        T: serde::ser::Serialize,
     {
         value.serialize(&mut *self.ser)
     }
@@ -510,14 +566,14 @@ pub struct SizeCompound<'a, S: SizeLimit + 'a> {
     ser: &'a mut SizeChecker<S>,
 }
 
-impl<'a, S: SizeLimit> serde::ser::SerializeSeq for SizeCompound<'a, S>
+impl<'a, S: SizeLimit> serde::ser::SerializeSeq for SizeCompound<'a, S> {
-{
     type Ok = ();
     type Error = Error;
 
     #[inline]
     fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<()>
-    where T: serde::ser::Serialize
+    where
+        T: serde::ser::Serialize,
     {
         value.serialize(&mut *self.ser)
     }
@@ -528,14 +584,14 @@ impl<'a, S: SizeLimit> serde::ser::SerializeSeq for SizeCompound<'a, S>
     }
 }
 
-impl<'a, S: SizeLimit> serde::ser::SerializeTuple for SizeCompound<'a, S>
+impl<'a, S: SizeLimit> serde::ser::SerializeTuple for SizeCompound<'a, S> {
-{
     type Ok = ();
     type Error = Error;
 
     #[inline]
     fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<()>
-    where T: serde::ser::Serialize
+    where
+        T: serde::ser::Serialize,
     {
         value.serialize(&mut *self.ser)
     }
@@ -546,14 +602,14 @@ impl<'a, S: SizeLimit> serde::ser::SerializeTuple for SizeCompound<'a, S>
     }
 }
 
-impl<'a, S: SizeLimit> serde::ser::SerializeTupleStruct for SizeCompound<'a, S>
+impl<'a, S: SizeLimit> serde::ser::SerializeTupleStruct for SizeCompound<'a, S> {
-{
     type Ok = ();
     type Error = Error;
 
     #[inline]
     fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<()>
-    where T: serde::ser::Serialize
+    where
+        T: serde::ser::Serialize,
     {
         value.serialize(&mut *self.ser)
     }
@@ -564,14 +620,14 @@ impl<'a, S: SizeLimit> serde::ser::SerializeTupleStruct for SizeCompound<'a, S>
     }
 }
 
-impl<'a, S: SizeLimit> serde::ser::SerializeTupleVariant for SizeCompound<'a, S>
+impl<'a, S: SizeLimit> serde::ser::SerializeTupleVariant for SizeCompound<'a, S> {
-{
     type Ok = ();
     type Error = Error;
 
     #[inline]
     fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<()>
-    where T: serde::ser::Serialize
+    where
+        T: serde::ser::Serialize,
     {
         value.serialize(&mut *self.ser)
     }
@@ -582,21 +638,22 @@ impl<'a, S: SizeLimit> serde::ser::SerializeTupleVariant for SizeCompound<'a, S>
     }
 }
 
-impl<'a, S: SizeLimit + 'a> serde::ser::SerializeMap for SizeCompound<'a, S>
+impl<'a, S: SizeLimit + 'a> serde::ser::SerializeMap for SizeCompound<'a, S> {
-{
     type Ok = ();
     type Error = Error;
 
     #[inline]
     fn serialize_key<K: ?Sized>(&mut self, value: &K) -> Result<()>
-    where K: serde::ser::Serialize
+    where
+        K: serde::ser::Serialize,
     {
         value.serialize(&mut *self.ser)
     }
 
-        #[inline]
+    #[inline]
     fn serialize_value<V: ?Sized>(&mut self, value: &V) -> Result<()>
-    where V: serde::ser::Serialize
+    where
+        V: serde::ser::Serialize,
     {
         value.serialize(&mut *self.ser)
     }
@@ -607,14 +664,14 @@ impl<'a, S: SizeLimit + 'a> serde::ser::SerializeMap for SizeCompound<'a, S>
     }
 }
 
-impl<'a, S: SizeLimit> serde::ser::SerializeStruct for SizeCompound<'a, S>
+impl<'a, S: SizeLimit> serde::ser::SerializeStruct for SizeCompound<'a, S> {
-{
     type Ok = ();
     type Error = Error;
 
     #[inline]
     fn serialize_field<T: ?Sized>(&mut self, _key: &'static str, value: &T) -> Result<()>
-    where T: serde::ser::Serialize
+    where
+        T: serde::ser::Serialize,
     {
         value.serialize(&mut *self.ser)
     }
@@ -625,14 +682,14 @@ impl<'a, S: SizeLimit> serde::ser::SerializeStruct for SizeCompound<'a, S>
     }
 }
 
-impl<'a, S: SizeLimit> serde::ser::SerializeStructVariant for SizeCompound<'a, S>
+impl<'a, S: SizeLimit> serde::ser::SerializeStructVariant for SizeCompound<'a, S> {
-{
     type Ok = ();
     type Error = Error;
 
     #[inline]
     fn serialize_field<T: ?Sized>(&mut self, _key: &'static str, value: &T) -> Result<()>
-    where T: serde::ser::Serialize
+    where
+        T: serde::ser::Serialize,
     {
         value.serialize(&mut *self.ser)
     }
@@ -642,13 +699,13 @@ impl<'a, S: SizeLimit> serde::ser::SerializeStructVariant for SizeCompound<'a, S
         Ok(())
     }
 }
-const TAG_CONT: u8    = 0b1000_0000;
+const TAG_CONT: u8 = 0b1000_0000;
-const TAG_TWO_B: u8   = 0b1100_0000;
+const TAG_TWO_B: u8 = 0b1100_0000;
 const TAG_THREE_B: u8 = 0b1110_0000;
-const TAG_FOUR_B: u8  = 0b1111_0000;
+const TAG_FOUR_B: u8 = 0b1111_0000;
-const MAX_ONE_B: u32   =     0x80;
+const MAX_ONE_B: u32 = 0x80;
-const MAX_TWO_B: u32   =    0x800;
+const MAX_TWO_B: u32 = 0x800;
-const MAX_THREE_B: u32 =  0x10000;
+const MAX_THREE_B: u32 = 0x10000;
 
 fn encode_utf8(c: char) -> EncodeUtf8 {
     let code = c as u32;
@@ -662,13 +719,13 @@ fn encode_utf8(c: char) -> EncodeUtf8 {
         2
     } else if code < MAX_THREE_B {
         buf[1] = (code >> 12 & 0x0F) as u8 | TAG_THREE_B;
-        buf[2] = (code >>  6 & 0x3F) as u8 | TAG_CONT;
+        buf[2] = (code >> 6 & 0x3F) as u8 | TAG_CONT;
         buf[3] = (code & 0x3F) as u8 | TAG_CONT;
         1
     } else {
         buf[0] = (code >> 18 & 0x07) as u8 | TAG_FOUR_B;
         buf[1] = (code >> 12 & 0x3F) as u8 | TAG_CONT;
-        buf[2] = (code >>  6 & 0x3F) as u8 | TAG_CONT;
+        buf[2] = (code >> 6 & 0x3F) as u8 | TAG_CONT;
         buf[3] = (code & 0x3F) as u8 | TAG_CONT;
         0
     };

tests/test.rs

@@ -10,16 +10,17 @@ use std::fmt::Debug;
 use std::collections::HashMap;
 use std::borrow::Cow;
 
-use bincode::{Infinite, Bounded};
+use bincode::{Bounded, Infinite};
 use bincode::{serialized_size, ErrorKind, Result};
-use bincode::internal::{serialize, deserialize, deserialize_from};
+use bincode::internal::{deserialize, deserialize_from, serialize};
 
 use bincode::serialize as serialize_little;
 use bincode::deserialize as deserialize_little;
 use bincode::deserialize_from as deserialize_from_little;
 
 fn the_same<V>(element: V)
-    where V: serde::Serialize+serde::de::DeserializeOwned+PartialEq+Debug+'static
+where
+    V: serde::Serialize + serde::de::DeserializeOwned + PartialEq + Debug + 'static,
 {
     let size = serialized_size(&element);
 
@@ -34,7 +35,8 @@ fn the_same<V>(element: V)
     {
         let encoded = serialize::<_, _, byteorder::BigEndian>(&element, Infinite).unwrap();
         let decoded = deserialize::<_, byteorder::BigEndian>(&encoded[..]).unwrap();
-        let decoded_reader = deserialize_from::<_, _, _, byteorder::BigEndian>(&mut &encoded[..], Infinite).unwrap();
+        let decoded_reader =
+            deserialize_from::<_, _, _, byteorder::BigEndian>(&mut &encoded[..], Infinite).unwrap();
 
         assert_eq!(element, decoded);
         assert_eq!(element, decoded_reader);
@@ -79,8 +81,8 @@ fn test_string() {
 #[test]
 fn test_tuple() {
     the_same((1isize,));
-    the_same((1isize,2isize,3isize));
+    the_same((1isize, 2isize, 3isize));
-    the_same((1isize,"foo".to_string(),()));
+    the_same((1isize, "foo".to_string(), ()));
 }
 
 #[test]
@@ -89,9 +91,13 @@ fn test_basic_struct() {
     struct Easy {
         x: isize,
         s: String,
-        y: usize
+        y: usize,
     }
-    the_same(Easy{x: -4, s: "foo".to_string(), y: 10});
+    the_same(Easy {
+        x: -4,
+        s: "foo".to_string(),
+        y: 10,
+    });
 }
 
 #[test]
@@ -100,19 +106,27 @@ fn test_nested_struct() {
     struct Easy {
         x: isize,
         s: String,
-        y: usize
+        y: usize,
     }
     #[derive(Serialize, Deserialize, PartialEq, Debug)]
     struct Nest {
         f: Easy,
         b: usize,
-        s: Easy
+        s: Easy,
     }
 
     the_same(Nest {
-        f: Easy {x: -1, s: "foo".to_string(), y: 20},
+        f: Easy {
+            x: -1,
+            s: "foo".to_string(),
+            y: 20,
+        },
         b: 100,
-        s: Easy {x: -100, s: "bar".to_string(), y: 20}
+        s: Easy {
+            x: -100,
+            s: "bar".to_string(),
+            y: 20,
+        },
     });
 }
 
@@ -147,15 +161,19 @@ fn test_enum() {
         OneArg(usize),
         Args(usize, usize),
         AnotherNoArg,
-        StructLike{x: usize, y: f32}
+        StructLike { x: usize, y: f32 },
     }
     the_same(TestEnum::NoArg);
     the_same(TestEnum::OneArg(4));
     //the_same(TestEnum::Args(4, 5));
     the_same(TestEnum::AnotherNoArg);
-    the_same(TestEnum::StructLike{x: 4, y: 3.14159});
+    the_same(TestEnum::StructLike { x: 4, y: 3.14159 });
-    the_same(vec![TestEnum::NoArg, TestEnum::OneArg(5), TestEnum::AnotherNoArg,
+    the_same(vec![
-                  TestEnum::StructLike{x: 4, y:1.4}]);
+        TestEnum::NoArg,
+        TestEnum::OneArg(5),
+        TestEnum::AnotherNoArg,
+        TestEnum::StructLike { x: 4, y: 1.4 },
+    ]);
 }
 
 #[test]
@@ -163,7 +181,7 @@ fn test_vec() {
     let v: Vec<u8> = vec![];
     the_same(v);
     the_same(vec![1u64]);
-    the_same(vec![1u64,2,3,4,5,6]);
+    the_same(vec![1u64, 2, 3, 4, 5, 6]);
 }
 
 #[test]
@@ -197,11 +215,11 @@ fn test_fixed_size_array() {
 fn deserializing_errors() {
 
     match *deserialize_little::<bool>(&vec![0xA][..]).unwrap_err() {
-        ErrorKind::InvalidBoolEncoding(0xA) => {},
+        ErrorKind::InvalidBoolEncoding(0xA) => {}
         _ => panic!(),
     }
     match *deserialize_little::<String>(&vec![1, 0, 0, 0, 0, 0, 0, 0, 0xFF][..]).unwrap_err() {
-        ErrorKind::InvalidUtf8Encoding(_) => {},
+        ErrorKind::InvalidUtf8Encoding(_) => {}
         _ => panic!(),
     }
 
@@ -214,23 +232,25 @@ fn deserializing_errors() {
 
     match *deserialize_little::<Test>(&vec![0, 0, 0, 5][..]).unwrap_err() {
         // Error message comes from serde
-        ErrorKind::Custom(_) => {},
+        ErrorKind::Custom(_) => {}
         _ => panic!(),
     }
     match *deserialize_little::<Option<u8>>(&vec![5, 0][..]).unwrap_err() {
-        ErrorKind::InvalidTagEncoding(_) => {},
+        ErrorKind::InvalidTagEncoding(_) => {}
         _ => panic!(),
     }
 }
 
 #[test]
 fn too_big_deserialize() {
-    let serialized = vec![0,0,0,3];
+    let serialized = vec![0, 0, 0, 3];
-    let deserialized: Result<u32> = deserialize_from_little::<_, _, _>(&mut &serialized[..], Bounded(3));
+    let deserialized: Result<u32> =
+        deserialize_from_little::<_, _, _>(&mut &serialized[..], Bounded(3));
     assert!(deserialized.is_err());
 
-    let serialized = vec![0,0,0,3];
+    let serialized = vec![0, 0, 0, 3];
-    let deserialized: Result<u32> = deserialize_from_little::<_, _, _>(&mut &serialized[..], Bounded(4));
+    let deserialized: Result<u32> =
+        deserialize_from_little::<_, _, _>(&mut &serialized[..], Bounded(4));
     assert!(deserialized.is_ok());
 }
 
@@ -247,7 +267,8 @@ fn char_serialization() {
 #[test]
 fn too_big_char_deserialize() {
     let serialized = vec![0x41];
-    let deserialized: Result<char> = deserialize_from_little::<_, _, _>(&mut &serialized[..], Bounded(1));
+    let deserialized: Result<char> =
+        deserialize_from_little::<_, _, _>(&mut &serialized[..], Bounded(1));
     assert!(deserialized.is_ok());
     assert_eq!(deserialized.unwrap(), 'A');
 }
@@ -297,7 +318,7 @@ fn encode_box() {
 
 #[test]
 fn test_cow_serialize() {
-    let large_object = vec![1u32,2,3,4,5,6];
+    let large_object = vec![1u32, 2, 3, 4, 5, 6];
     let mut large_map = HashMap::new();
     large_map.insert(1, 2);
 
@@ -305,28 +326,32 @@ fn test_cow_serialize() {
     #[derive(Serialize, Deserialize, Debug)]
     enum Message<'a> {
         M1(Cow<'a, Vec<u32>>),
-        M2(Cow<'a, HashMap<u32, u32>>)
+        M2(Cow<'a, HashMap<u32, u32>>),
     }
 
     // Test 1
     {
-        let serialized = serialize_little(&Message::M1(Cow::Borrowed(&large_object)), Infinite).unwrap();
+        let serialized =
-        let deserialized: Message<'static> = deserialize_from_little(&mut &serialized[..], Infinite).unwrap();
+            serialize_little(&Message::M1(Cow::Borrowed(&large_object)), Infinite).unwrap();
+        let deserialized: Message<'static> =
+            deserialize_from_little(&mut &serialized[..], Infinite).unwrap();
 
         match deserialized {
             Message::M1(b) => assert!(&b.into_owned() == &large_object),
-            _ => assert!(false)
+            _ => assert!(false),
         }
     }
 
     // Test 2
     {
-        let serialized = serialize_little(&Message::M2(Cow::Borrowed(&large_map)), Infinite).unwrap();
+        let serialized =
-        let deserialized: Message<'static> = deserialize_from_little(&mut &serialized[..], Infinite).unwrap();
+            serialize_little(&Message::M2(Cow::Borrowed(&large_map)), Infinite).unwrap();
+        let deserialized: Message<'static> =
+            deserialize_from_little(&mut &serialized[..], Infinite).unwrap();
 
         match deserialized {
             Message::M2(b) => assert!(&b.into_owned() == &large_map),
-            _ => assert!(false)
+            _ => assert!(false),
         }
     }
 }
@@ -335,17 +360,19 @@ fn test_cow_serialize() {
 fn test_strbox_serialize() {
     let strx: &'static str = "hello world";
     let serialized = serialize_little(&Cow::Borrowed(strx), Infinite).unwrap();
-    let deserialized: Cow<'static, String> = deserialize_from_little(&mut &serialized[..], Infinite).unwrap();
+    let deserialized: Cow<'static, String> =
+        deserialize_from_little(&mut &serialized[..], Infinite).unwrap();
     let stringx: String = deserialized.into_owned();
     assert!(strx == &stringx[..]);
 }
 
 #[test]
 fn test_slicebox_serialize() {
-    let slice = [1u32, 2, 3 ,4, 5];
+    let slice = [1u32, 2, 3, 4, 5];
     let serialized = serialize_little(&Cow::Borrowed(&slice[..]), Infinite).unwrap();
     println!("{:?}", serialized);
-    let deserialized: Cow<'static, Vec<u32>> = deserialize_from_little(&mut &serialized[..], Infinite).unwrap();
+    let deserialized: Cow<'static, Vec<u32>> =
+        deserialize_from_little(&mut &serialized[..], Infinite).unwrap();
     {
         let sb: &[u32] = &deserialized;
         assert!(slice == sb);
@@ -365,9 +392,15 @@ fn test_oom_protection() {
     #[derive(Serialize, Deserialize, PartialEq, Debug)]
     struct FakeVec {
         len: u64,
-        byte: u8
+        byte: u8,
     }
-    let x = serialize_little(&FakeVec { len: 0xffffffffffffffffu64, byte: 1 }, Bounded(10)).unwrap();
+    let x = serialize_little(
+        &FakeVec {
+            len: 0xffffffffffffffffu64,
+            byte: 1,
+        },
+        Bounded(10),
+    ).unwrap();
     let y: Result<Vec<u8>> = deserialize_from_little(&mut Cursor::new(&x[..]), Bounded(10));
     assert!(y.is_err());
 }
@@ -394,7 +427,7 @@ fn bytes() {
 #[test]
 fn serde_bytes() {
     use serde_bytes::ByteBuf;
-    the_same(ByteBuf::from(vec![1,2,3,4,5]));
+    the_same(ByteBuf::from(vec![1, 2, 3, 4, 5]));
 }