Fix clippy lints

Author: jayvdb

src/isobmff.rs

@@ -127,7 +127,7 @@ impl<R> Parser<R> where R: BufRead + Seek {
         let mut buf = [0; 8];
         self.reader.read_exact(&mut buf)?;
         let size = match BigEndian::loadu32(&buf, 0) {
-            0 => Some(std::u64::MAX),
+            0 => Some(u64::MAX),
             1 => read64(&mut self.reader)?.checked_sub(16),
             x => u64::from(x).checked_sub(8),
         }.ok_or("Invalid box size")?;
@@ -138,7 +138,7 @@ impl<R> Parser<R> where R: BufRead + Seek {
     fn read_file_level_box(&mut self, size: u64) -> Result<Vec<u8>, Error> {
         let mut buf;
         match size {
-            std::u64::MAX => {
+            u64::MAX => {
                 buf = Vec::new();
                 self.reader.read_to_end(&mut buf)?;
             },
@@ -154,7 +154,7 @@ impl<R> Parser<R> where R: BufRead + Seek {
 
     fn skip_file_level_box(&mut self, size: u64) -> Result<(), Error> {
         match size {
-            std::u64::MAX => self.reader.seek(SeekFrom::End(0))?,
+            u64::MAX => self.reader.seek(SeekFrom::End(0))?,
             _ => self.reader.seek(SeekFrom::Current(
                 size.try_into().or(Err("Large seek not supported"))?))?,
         };
@@ -164,7 +164,7 @@ impl<R> Parser<R> where R: BufRead + Seek {
     fn parse_ftyp(&mut self, mut boxp: BoxSplitter) -> Result<(), Error> {
         let head = boxp.slice(8)?;
         let _major_brand = &head[0..4];
-        let _minor_version = BigEndian::loadu32(&head, 4);
+        let _minor_version = BigEndian::loadu32(head, 4);
         while let Ok(compat_brand) = boxp.array4() {
             if HEIF_BRANDS.contains(&compat_brand) {
                 return Ok(());
@@ -301,9 +301,8 @@ impl<R> Parser<R> where R: BufRead + Seek {
         };
         for _ in 0..entry_count {
             let (boxtype, body) = boxp.child_box()?;
-            match boxtype {
-                b"infe" => self.parse_infe(body)?,
-                _ => {},
+            if boxtype == b"infe" {
+                self.parse_infe(body)?;
             }
         }
         Ok(())
@@ -483,7 +482,7 @@ mod tests {
         // to the end of the file
         let mut p = Parser::new(Cursor::new(b"\0\0\0\0abcd"));
         assert_eq!(p.read_box_header().unwrap(),
-                   Some((std::u64::MAX, *b"abcd")));
+                   Some((u64::MAX, *b"abcd")));
         // largesize
         let mut p = Parser::new(Cursor::new(
             b"\0\0\0\x01abcd\0\0\0\0\0\0\0\x10"));
@@ -498,7 +497,7 @@ mod tests {
         let mut p = Parser::new(Cursor::new(
             b"\0\0\0\x01abcd\xff\xff\xff\xff\xff\xff\xff\xff"));
         assert_eq!(p.read_box_header().unwrap(),
-                   Some((std::u64::MAX.wrapping_sub(16), *b"abcd")));
+                   Some((u64::MAX.wrapping_sub(16), *b"abcd")));
     }
 
     #[test]

src/tag.rs

@@ -749,7 +749,7 @@ generate_well_known_tag_constants!(
 );
 
 // For Value::display_as().
-pub fn display_value_as<'a>(value: &'a Value, tag: Tag) -> value::Display<'a> {
+pub fn display_value_as(value: &Value, tag: Tag) -> value::Display<'_> {
     match get_tag_info(tag) {
         Some(ti) => value::Display { fmt: ti.dispval, value: value },
         None => value::Display { fmt: d_default, value: value },
@@ -1463,7 +1463,7 @@ where I: IntoIterator<Item = T>, T: fmt::Display {
 
 struct AsciiDisplay<'a>(&'a [u8]);
 
-impl<'a> fmt::Display for AsciiDisplay<'a> {
+impl fmt::Display for AsciiDisplay<'_> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         d_sub_ascii(f, self.0)
     }

src/tiff.rs

@@ -507,7 +507,7 @@ impl<'a> DisplayValue<'a> {
     }
 }
 
-impl<'a> fmt::Display for DisplayValue<'a> {
+impl fmt::Display for DisplayValue<'_> {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         self.value_display.fmt(f)

src/util.rs

@@ -58,7 +58,7 @@ impl<T> BufReadExt for T where T: io::BufRead {
     fn discard_exact(&mut self, mut len: usize) -> io::Result<()> {
         while len > 0 {
             let consume_len = match self.fill_buf() {
-                Ok(buf) if buf.is_empty() =>
+                Ok([]) =>
                     return Err(io::Error::new(
                         io::ErrorKind::UnexpectedEof, "unexpected EOF")),
                 Ok(buf) => buf.len().min(len),

src/value.rs

@@ -224,7 +224,7 @@ pub struct UIntIter<'a> {
     iter: Box<dyn ExactSizeIterator<Item=u32> + 'a>
 }
 
-impl<'a> Iterator for UIntIter<'a> {
+impl Iterator for UIntIter<'_> {
     type Item = u32;
 
     #[inline]
@@ -238,7 +238,7 @@ impl<'a> Iterator for UIntIter<'a> {
     }
 }
 
-impl<'a> ExactSizeIterator for UIntIter<'a> {}
+impl ExactSizeIterator for UIntIter<'_> {}
 
 /// Helper struct for printing a value in a tag-specific format.
 #[derive(Copy, Clone)]
@@ -247,7 +247,7 @@ pub struct Display<'a> {
     pub value: &'a Value,
 }
 
-impl<'a> fmt::Display for Display<'a> {
+impl fmt::Display for Display<'_> {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         (self.fmt)(f, self.value)
@@ -292,7 +292,7 @@ where F: Fn() -> T, T: Iterator<Item = I>, I: fmt::Debug {
 
 struct AsciiDebugAdapter<'a>(&'a [u8]);
 
-impl<'a> fmt::Debug for AsciiDebugAdapter<'a> {
+impl fmt::Debug for AsciiDebugAdapter<'_> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.write_char('"')?;
         self.0.iter().try_for_each(|&c| match c {
@@ -306,7 +306,7 @@ impl<'a> fmt::Debug for AsciiDebugAdapter<'a> {
 
 struct HexDebugAdapter<'a>(&'a [u8]);
 
-impl<'a> fmt::Debug for HexDebugAdapter<'a> {
+impl fmt::Debug for HexDebugAdapter<'_> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.write_str("0x")?;
         self.0.iter().try_for_each(|x| write!(f, "{:02x}", x))
@@ -471,9 +471,9 @@ fn parse_byte(data: &[u8], offset: usize, count: usize) -> Value {
 fn parse_ascii(data: &[u8], offset: usize, count: usize) -> Value {
     // Any ASCII field can contain multiple strings [TIFF6 Image File
     // Directory].
-    let iter = (&data[offset .. offset + count]).split(|&b| b == b'\0');
+    let iter = data[offset .. offset + count].split(|&b| b == b'\0');
     let mut v: Vec<Vec<u8>> = iter.map(|x| x.to_vec()).collect();
-    if v.last().map_or(false, |x| x.len() == 0) {
+    if v.last().map_or(false, |x| x.is_empty()) {
         v.pop();
     }
     Value::Ascii(v)

src/writer.rs

@@ -74,7 +74,7 @@ struct Ifd<'a> {
     jpeg: Option<&'a [u8]>,
 }
 
-impl<'a> Ifd<'a> {
+impl Ifd<'_> {
     fn is_empty(&self) -> bool {
         self.tiff_fields.is_empty() &&
             self.exif_fields.is_empty() &&
@@ -191,7 +191,7 @@ impl<'a> Writer<'a> {
                 ifd_num_ck.ok_or(Error::InvalidFormat("Too many IFDs"))?;
             if ifd_num > 0 {
                 let next_ifd_offset = pad_and_get_offset(w)?;
-                let origpos = w.seek(SeekFrom::Current(0))?;
+                let origpos = w.stream_position()?;
                 w.seek(SeekFrom::Start(next_ifd_offset_offset as u64))?;
                 match little_endian {
                     false => BigEndian::writeu32(w, next_ifd_offset)?,
@@ -342,15 +342,15 @@ fn write_image<W, E>(w: &mut W, ws: &WriterState, ifd: &Ifd)
          strip_offsets_offset, tile_offsets_offset, jpeg_offset) =
         write_ifd_and_fields::<_, E>(
             w, &ws.tiff_fields, ws.tiff_ifd_offset)?;
-    if ws.exif_fields.len() > 0 {
+    if !ws.exif_fields.is_empty() {
         write_ifd_and_fields::<_, E>(
             w, &ws.exif_fields, ws.exif_ifd_offset)?;
     }
-    if ws.gps_fields.len() > 0 {
+    if !ws.gps_fields.is_empty() {
         write_ifd_and_fields::<_, E>(
             w, &ws.gps_fields, ws.gps_ifd_offset)?;
     }
-    if ws.interop_fields.len() > 0 {
+    if !ws.interop_fields.is_empty() {
         write_ifd_and_fields::<_, E>(
             w, &ws.interop_fields, ws.interop_ifd_offset)?;
     }
@@ -361,7 +361,7 @@ fn write_image<W, E>(w: &mut W, ws: &WriterState, ifd: &Ifd)
             strip_offsets.push(get_offset(w)?);
             w.write_all(strip)?;
         }
-        let origpos = w.seek(SeekFrom::Current(0))?;
+        let origpos = w.stream_position()?;
         w.seek(SeekFrom::Start(strip_offsets_offset as u64))?;
         for ofs in strip_offsets {
             E::writeu32(w, ofs)?;
@@ -374,7 +374,7 @@ fn write_image<W, E>(w: &mut W, ws: &WriterState, ifd: &Ifd)
             tile_offsets.push(get_offset(w)?);
             w.write_all(tile)?;
         }
-        let origpos = w.seek(SeekFrom::Current(0))?;
+        let origpos = w.stream_position()?;
         w.seek(SeekFrom::Start(tile_offsets_offset as u64))?;
         for ofs in tile_offsets {
             E::writeu32(w, ofs)?;
@@ -384,7 +384,7 @@ fn write_image<W, E>(w: &mut W, ws: &WriterState, ifd: &Ifd)
     if let Some(jpeg) = ifd.jpeg {
         let offset = get_offset(w)?;
         w.write_all(jpeg)?;
-        let origpos = w.seek(SeekFrom::Current(0))?;
+        let origpos = w.stream_position()?;
         w.seek(SeekFrom::Start(jpeg_offset as u64))?;
         E::writeu32(w, offset)?;
         w.seek(SeekFrom::Start(origpos))?;
@@ -552,7 +552,7 @@ fn compose_value<E>(value: &Value)
 
 fn write_at<W>(w: &mut W, buf: &[u8], offset: u32)
                -> io::Result<()> where W: Write + Seek {
-    let orig = w.seek(SeekFrom::Current(0))?;
+    let orig = w.stream_position()?;
     w.seek(SeekFrom::Start(offset as u64))?;
     w.write_all(buf)?;
     w.seek(SeekFrom::Start(orig))?;
@@ -562,7 +562,7 @@ fn write_at<W>(w: &mut W, buf: &[u8], offset: u32)
 // Aligns `w` to the two-byte (word) boundary and returns the new offset.
 fn pad_and_get_offset<W>(w: &mut W)
                          -> Result<u32, Error> where W: Write + Seek {
-    let mut pos = w.seek(SeekFrom::Current(0))?;
+    let mut pos = w.stream_position()?;
     if pos >= (1 << 32) - 1 {
         return Err(Error::TooBig("Offset too large"));
     }
@@ -575,7 +575,7 @@ fn pad_and_get_offset<W>(w: &mut W)
 
 fn get_offset<W>(w: &mut W)
                  -> Result<u32, Error> where W: Write + Seek {
-    let pos = w.seek(SeekFrom::Current(0))?;
+    let pos = w.stream_position()?;
     if pos as u32 as u64 != pos {
         return Err(Error::TooBig("Offset too large"));
     }

tests/rwrcmp.rs

@@ -106,7 +106,7 @@ fn rwr_compare<P>(path: P) where P: AsRef<Path> {
     if let Some(ref tiles) = tiles {
         writer.set_tiles(tiles, In::PRIMARY);
     }
-    if let Some(ref tn_jpeg) = tn_jpeg {
+    if let Some(tn_jpeg) = tn_jpeg {
         writer.set_jpeg(tn_jpeg, In::THUMBNAIL);
     }
     let mut out = Cursor::new(Vec::new());