Run rustfmt over the library

Byron · Oct 30, 2015 · 4b85197 · 4b85197
1 parent c494b5e
commit 4b85197
Show file tree

Hide file tree

Showing 8 changed files with 312 additions and 139 deletions.
diff --git a/src/crc.rs b/src/crc.rs
@@ -21,8 +21,13 @@ impl Crc {
         Crc { crc: 0, amt: 0 }
     }
 
-    pub fn sum(&self) -> libc::c_ulong { self.crc }
-    pub fn amt(&self) -> u32 { self.amt }
+    pub fn sum(&self) -> libc::c_ulong {
+        self.crc
+    }
+
+    pub fn amt(&self) -> u32 {
+        self.amt
+    }
 
     pub fn update(&mut self, data: &[u8]) {
         self.amt += data.len() as u32;
@@ -34,11 +39,23 @@ impl Crc {
 
 impl<R: Read> CrcReader<R> {
     pub fn new(r: R) -> CrcReader<R> {
-        CrcReader { inner: r, crc: Crc::new() }
+        CrcReader {
+            inner: r,
+            crc: Crc::new(),
+        }
+    }
+
+    pub fn crc(&self) -> &Crc {
+        &self.crc
+    }
+
+    pub fn into_inner(self) -> R {
+        self.inner
+    }
+
+    pub fn inner(&mut self) -> &mut R {
+        &mut self.inner
     }
-    pub fn crc(&self) -> &Crc { &self.crc }
-    pub fn into_inner(self) -> R { self.inner }
-    pub fn inner(&mut self) -> &mut R { &mut self.inner }
 }
 
 impl<R: Read> Read for CrcReader<R> {

diff --git a/src/deflate.rs b/src/deflate.rs
@@ -45,7 +45,9 @@ impl<W: Write> EncoderWriter<W> {
     /// be flushed.
     pub fn new(w: W, level: ::Compression) -> EncoderWriter<W> {
         EncoderWriter {
-            inner: raw::EncoderWriter::new(w, level, true,
+            inner: raw::EncoderWriter::new(w,
+                                           level,
+                                           true,
                                            Vec::with_capacity(32 * 1024)),
         }
     }
@@ -77,8 +79,13 @@ impl<W: Write> EncoderWriter<W> {
 }
 
 impl<W: Write> Write for EncoderWriter<W> {
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> { self.inner.write(buf) }
-    fn flush(&mut self) -> io::Result<()> { self.inner.flush() }
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        self.inner.write(buf)
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        self.inner.flush()
+    }
 }
 
 impl<R: Read> EncoderReader<R> {
@@ -158,7 +165,8 @@ impl<W: Write> DecoderWriter<W> {
     /// be flushed.
     pub fn new(w: W) -> DecoderWriter<W> {
         DecoderWriter {
-            inner: raw::DecoderWriter::new(w, true,
+            inner: raw::DecoderWriter::new(w,
+                                           true,
                                            Vec::with_capacity(32 * 1024)),
         }
     }
@@ -190,8 +198,13 @@ impl<W: Write> DecoderWriter<W> {
 }
 
 impl<W: Write> Write for DecoderWriter<W> {
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> { self.inner.write(buf) }
-    fn flush(&mut self) -> io::Result<()> { self.inner.flush() }
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        self.inner.write(buf)
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        self.inner.flush()
+    }
 }
 
 #[cfg(test)]
@@ -222,7 +235,10 @@ mod tests {
 
     #[test]
     fn roundtrip2() {
-        let v = thread_rng().gen_iter::<u8>().take(1024 * 1024).collect::<Vec<_>>();
+        let v = thread_rng()
+                    .gen_iter::<u8>()
+                    .take(1024 * 1024)
+                    .collect::<Vec<_>>();
         let mut r = DecoderReader::new(EncoderReader::new(&v[..], Default));
         let mut ret = Vec::new();
         r.read_to_end(&mut ret).unwrap();
@@ -231,7 +247,10 @@ mod tests {
 
     #[test]
     fn roundtrip3() {
-        let v = thread_rng().gen_iter::<u8>().take(1024 * 1024).collect::<Vec<_>>();
+        let v = thread_rng()
+                    .gen_iter::<u8>()
+                    .take(1024 * 1024)
+                    .collect::<Vec<_>>();
         let mut w = EncoderWriter::new(DecoderWriter::new(Vec::new()), Default);
         w.write_all(&v).unwrap();
         let w = w.finish().unwrap().finish().unwrap();
@@ -240,8 +259,10 @@ mod tests {
 
     #[test]
     fn reset_writer() {
-        let v = thread_rng().gen_iter::<u8>().take(1024 * 1024)
-                            .collect::<Vec<_>>();
+        let v = thread_rng()
+                    .gen_iter::<u8>()
+                    .take(1024 * 1024)
+                    .collect::<Vec<_>>();
         let mut w = EncoderWriter::new(Vec::new(), Default);
         w.write_all(&v).unwrap();
         let a = w.reset(Vec::new()).unwrap();
@@ -256,8 +277,10 @@ mod tests {
 
     #[test]
     fn reset_reader() {
-        let v = thread_rng().gen_iter::<u8>().take(1024 * 1024)
-                            .collect::<Vec<_>>();
+        let v = thread_rng()
+                    .gen_iter::<u8>()
+                    .take(1024 * 1024)
+                    .collect::<Vec<_>>();
         let (mut a, mut b, mut c) = (Vec::new(), Vec::new(), Vec::new());
         let mut r = EncoderReader::new(&v[..], Default);
         r.read_to_end(&mut a).unwrap();
@@ -271,8 +294,10 @@ mod tests {
 
     #[test]
     fn reset_decoder() {
-        let v = thread_rng().gen_iter::<u8>().take(1024 * 1024)
-                            .collect::<Vec<_>>();
+        let v = thread_rng()
+                    .gen_iter::<u8>()
+                    .take(1024 * 1024)
+                    .collect::<Vec<_>>();
         let mut w = EncoderWriter::new(Vec::new(), Default);
         w.write_all(&v).unwrap();
         let data = w.finish().unwrap();