A bunch of clippy fixes

src/encoder/compression/deflate.rs

@@ -46,7 +46,7 @@ impl Compression for Deflate {
     const COMPRESSION_METHOD: CompressionMethod = CompressionMethod::Deflate;
 
     fn get_algorithm(&self) -> Compressor {
-        Compressor::Deflate(self.clone())
+        Compressor::Deflate(*self)
     }
 }
 

src/encoder/compression/lzw.rs

@@ -41,7 +41,7 @@ mod tests {
 
         let mut compressed_data = Vec::<u8>::new();
         let mut writer = Cursor::new(&mut compressed_data);
-        Lzw::default().write_to(&mut writer, TEST_DATA).unwrap();
+        Lzw.write_to(&mut writer, TEST_DATA).unwrap();
         assert_eq!(EXPECTED_COMPRESSED_DATA, compressed_data.as_slice());
     }
 }

src/encoder/compression/mod.rs

@@ -38,7 +38,7 @@ pub enum Compressor {
 impl Default for Compressor {
     /// The default compression strategy does not apply any compression.
     fn default() -> Self {
-        Compressor::Uncompressed(Uncompressed::default())
+        Compressor::Uncompressed(Uncompressed)
     }
 }
 
@@ -55,6 +55,6 @@ impl CompressionAlgorithm for Compressor {
 
 #[cfg(test)]
 mod tests {
-    pub const TEST_DATA: &'static [u8] =
+    pub const TEST_DATA: &[u8] =
         b"This is a string for checking various compression algorithms.";
 }

src/encoder/compression/packbits.rs

@@ -80,33 +80,31 @@ impl CompressionAlgorithm for Packbits {
                     run_index = 0;
                     in_run = false;
                 }
-            } else {
-                if bytes_pending > MAX_BYTES {
-                    // We have as much differing data as we can output in one chunk.
-                    // Output MAX_BYTES leaving one byte.
-                    offset.get_or_insert(write_u8(&mut bufwriter, encode_diff(MAX_BYTES))?);
-                    bufwriter.write(&bytes[pending_index..pending_index + MAX_BYTES as usize])?;
-                    bytes_written += 1 + MAX_BYTES as u64;
+            } else if bytes_pending > MAX_BYTES {
+                // We have as much differing data as we can output in one chunk.
+                // Output MAX_BYTES leaving one byte.
+                offset.get_or_insert(write_u8(&mut bufwriter, encode_diff(MAX_BYTES))?);
+                bufwriter.write_all(&bytes[pending_index..pending_index + MAX_BYTES as usize])?;
+                bytes_written += 1 + MAX_BYTES as u64;
 
-                    pending_index += MAX_BYTES as usize;
-                    bytes_pending -= MAX_BYTES;
-                    run_index = bytes_pending - 1; // A run could start here
-                } else if curr_byte == last_byte {
-                    if (bytes_pending - run_index >= MIN_REPT) || (run_index == 0) {
-                        // This is a worthwhile run
-                        if run_index != 0 {
-                            // Flush differing data out of input buffer
-                            offset.get_or_insert(write_u8(&mut bufwriter, encode_diff(run_index))?);
-                            bufwriter
-                                .write(&bytes[pending_index..pending_index + run_index as usize])?;
-                            bytes_written += 1 + run_index as u64;
-                        }
-                        bytes_pending -= run_index; // Length of run
-                        in_run = true;
+                pending_index += MAX_BYTES as usize;
+                bytes_pending -= MAX_BYTES;
+                run_index = bytes_pending - 1; // A run could start here
+            } else if curr_byte == last_byte {
+                if (bytes_pending - run_index >= MIN_REPT) || (run_index == 0) {
+                    // This is a worthwhile run
+                    if run_index != 0 {
+                        // Flush differing data out of input buffer
+                        offset.get_or_insert(write_u8(&mut bufwriter, encode_diff(run_index))?);
+                        bufwriter
+                            .write_all(&bytes[pending_index..pending_index + run_index as usize])?;
+                        bytes_written += 1 + run_index as u64;
                     }
-                } else {
-                    run_index = bytes_pending - 1; // A run could start here
+                    bytes_pending -= run_index; // Length of run
+                    in_run = true;
                 }
+            } else {
+                run_index = bytes_pending - 1; // A run could start here
             }
             last_byte = curr_byte;
         }
@@ -119,7 +117,7 @@ impl CompressionAlgorithm for Packbits {
         } else {
             bytes_written += 1 + bytes_pending as u64;
             offset.get_or_insert(write_u8(&mut bufwriter, encode_diff(bytes_pending))?);
-            bufwriter.write(&bytes[pending_index..pending_index + bytes_pending as usize])?;
+            bufwriter.write_all(&bytes[pending_index..pending_index + bytes_pending as usize])?;
         }
 
         bufwriter.flush()?;
@@ -141,7 +139,7 @@ mod tests {
 
         let mut compressed_data = Vec::<u8>::new();
         let mut writer = Cursor::new(&mut compressed_data);
-        Packbits::default()
+        Packbits
             .write_to(&mut writer, &UNCOMPRESSED_DATA)
             .unwrap();
         assert_eq!(compressed_data, EXPECTED_COMPRESSED_DATA);
@@ -150,13 +148,13 @@ mod tests {
     #[test]
     fn test_packbits_rept() {
         // compress buffer with repetitive sequence
-        const UNCOMPRESSED_DATA: &'static [u8] =
+        const UNCOMPRESSED_DATA: &[u8] =
             b"This strrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrring hangs.";
-        const EXPECTED_COMPRESSED_DATA: &'static [u8] = b"\x06This st\xD1r\x09ing hangs.";
+        const EXPECTED_COMPRESSED_DATA: &[u8] = b"\x06This st\xD1r\x09ing hangs.";
 
         let mut compressed_data = Vec::<u8>::new();
         let mut writer = Cursor::new(&mut compressed_data);
-        Packbits::default()
+        Packbits
             .write_to(&mut writer, UNCOMPRESSED_DATA)
             .unwrap();
         assert_eq!(compressed_data, EXPECTED_COMPRESSED_DATA);
@@ -192,7 +190,7 @@ mod tests {
 
         let mut compressed_data = Vec::<u8>::new();
         let mut writer = Cursor::new(&mut compressed_data);
-        Packbits::default()
+        Packbits
             .write_to(&mut writer, data.as_slice())
             .unwrap();
         assert_eq!(compressed_data, EXPECTED_COMPRESSED_DATA);
@@ -201,12 +199,12 @@ mod tests {
     #[test]
     fn test_packbits() {
         // compress teststring
-        const EXPECTED_COMPRESSED_DATA: &'static [u8] =
+        const EXPECTED_COMPRESSED_DATA: &[u8] =
             b"\x3CThis is a string for checking various compression algorithms.";
 
         let mut compressed_data = Vec::<u8>::new();
         let mut writer = Cursor::new(&mut compressed_data);
-        Packbits::default()
+        Packbits
             .write_to(&mut writer, TEST_DATA)
             .unwrap();
         assert_eq!(compressed_data, EXPECTED_COMPRESSED_DATA);

src/encoder/compression/uncompressed.rs

@@ -29,7 +29,7 @@ mod tests {
     fn test_no_compression() {
         let mut compressed_data = Vec::<u8>::new();
         let mut writer = Cursor::new(&mut compressed_data);
-        Uncompressed::default()
+        Uncompressed
             .write_to(&mut writer, TEST_DATA)
             .unwrap();
         assert_eq!(TEST_DATA, compressed_data);

src/encoder/mod.rs

@@ -219,19 +219,19 @@ impl<'a, W: 'a + Write + Seek, K: TiffKind> DirectoryEncoder<'a, W, K> {
 
         let offset = self.writer.offset();
 
-        K::write_entry_count(&mut self.writer, self.ifd.len())?;
+        K::write_entry_count(self.writer, self.ifd.len())?;
         for (
             tag,
-            &DirectoryEntry {
-                data_type: ref field_type,
-                ref count,
-                data: ref offset,
+            DirectoryEntry {
+                data_type: field_type,
+                count,
+                data: offset,
             },
         ) in self.ifd.iter()
         {
             self.writer.write_u16(*tag)?;
             self.writer.write_u16(*field_type)?;
-            (*count).write(&mut self.writer)?;
+            (*count).write(self.writer)?;
             self.writer.write_bytes(offset)?;
         }
 
@@ -243,7 +243,7 @@ impl<'a, W: 'a + Write + Seek, K: TiffKind> DirectoryEncoder<'a, W, K> {
     /// This could be used to write tiff strips.
     pub fn write_data<T: TiffValue>(&mut self, value: T) -> TiffResult<u64> {
         let offset = self.writer.offset();
-        value.write(&mut self.writer)?;
+        value.write(self.writer)?;
         Ok(offset)
     }
 
@@ -257,9 +257,9 @@ impl<'a, W: 'a + Write + Seek, K: TiffKind> DirectoryEncoder<'a, W, K> {
         let curr_pos = self.writer.offset();
 
         self.writer.goto_offset(self.ifd_pointer_pos)?;
-        K::write_offset(&mut self.writer, ifd_pointer)?;
+        K::write_offset(self.writer, ifd_pointer)?;
         self.writer.goto_offset(curr_pos)?;
-        K::write_offset(&mut self.writer, 0)?;
+        K::write_offset(self.writer, 0)?;
 
         self.dropped = true;
 
@@ -400,7 +400,7 @@ impl<'a, W: 'a + Write + Seek, T: ColorType, K: TiffKind, D: Compression>
             strip_offsets: Vec::new(),
             strip_byte_count: Vec::new(),
             dropped: false,
-            compression: compression,
+            compression,
             _phantom: ::std::marker::PhantomData,
         })
     }

src/encoder/writer.rs

@@ -182,7 +182,7 @@ impl<W: Write> TiffWriter<W> {
 impl<W: Seek> TiffWriter<W> {
     pub fn goto_offset(&mut self, offset: u64) -> Result<(), io::Error> {
         self.offset = offset;
-        self.writer.seek(SeekFrom::Start(offset as u64))?;
+        self.writer.seek(SeekFrom::Start(offset))?;
         Ok(())
     }
 }