fixed clippy

feefladder · feefladder · commit b0bddcfd454a · 2025-03-25T19:35:58.000+01:00
diff --git a/src/ifd.rs b/src/ifd.rs
@@ -887,9 +887,9 @@ async fn read_tag_value(
         // value fits in offset field
         let res = cursor.read(value_byte_length).await?;
         if bigtiff {
-            cursor.advance(8-value_byte_length);
+            cursor.advance(8 - value_byte_length);
         } else {
-            cursor.advance(4-value_byte_length);
+            cursor.advance(4 - value_byte_length);
         }
         res
     } else {
@@ -899,7 +899,11 @@ async fn read_tag_value(
         } else {
             cursor.read_u32().await?.into()
         };
-        let reader = cursor.reader().get_bytes(offset..offset+value_byte_length).await?.reader();
+        let reader = cursor
+            .reader()
+            .get_bytes(offset..offset + value_byte_length)
+            .await?
+            .reader();
         EndianAwareReader::new(reader, cursor.endianness())
         // cursor.seek(offset);
         // cursor.read(value_byte_length).await?
@@ -934,18 +938,18 @@ async fn read_tag_value(
 
     match tag_type {
         Type::BYTE | Type::UNDEFINED => {
-            let mut v = Vec::new();
+            let mut v = Vec::with_capacity(count as _);
             for _ in 0..count {
                 v.push(Value::Byte(data.read_u8()?));
             }
-            return Ok(Value::List(v));
+            Ok(Value::List(v))
         }
         Type::SBYTE => {
-            let mut v = Vec::new();
+            let mut v = Vec::with_capacity(count as _);
             for _ in 0..count {
                 v.push(Value::SignedByte(data.read_i8()?));
             }
-            return Ok(Value::List(v));
+            Ok(Value::List(v))
         }
         Type::ASCII => {
             let mut buf = vec![0; count as usize];
@@ -954,95 +958,95 @@ async fn read_tag_value(
                 let v = std::str::from_utf8(&buf)
                     .map_err(|err| AsyncTiffError::General(err.to_string()))?;
                 let v = v.trim_matches(char::from(0));
-                return Ok(Value::Ascii(v.into()));
+                Ok(Value::Ascii(v.into()))
             } else {
                 panic!("Invalid tag");
                 // return Err(TiffError::FormatError(TiffFormatError::InvalidTag));
             }
         }
         Type::SHORT => {
-            let mut v = Vec::new();
+            let mut v = Vec::with_capacity(count as _);
             for _ in 0..count {
                 v.push(Value::Short(data.read_u16()?));
             }
-            return Ok(Value::List(v));
+            Ok(Value::List(v))
         }
         Type::SSHORT => {
-            let mut v = Vec::new();
+            let mut v = Vec::with_capacity(count as _);
             for _ in 0..count {
                 v.push(Value::Signed(i32::from(data.read_i16()?)));
             }
-            return Ok(Value::List(v));
+            Ok(Value::List(v))
         }
         Type::LONG => {
-            let mut v = Vec::new();
+            let mut v = Vec::with_capacity(count as _);
             for _ in 0..count {
                 v.push(Value::Unsigned(data.read_u32()?));
             }
-            return Ok(Value::List(v));
+            Ok(Value::List(v))
         }
         Type::SLONG => {
-            let mut v = Vec::new();
+            let mut v = Vec::with_capacity(count as _);
             for _ in 0..count {
                 v.push(Value::Signed(data.read_i32()?));
             }
-            return Ok(Value::List(v));
+            Ok(Value::List(v))
         }
         Type::FLOAT => {
-            let mut v = Vec::new();
+            let mut v = Vec::with_capacity(count as _);
             for _ in 0..count {
                 v.push(Value::Float(data.read_f32()?));
             }
-            return Ok(Value::List(v));
+            Ok(Value::List(v))
         }
         Type::DOUBLE => {
             let mut v = Vec::with_capacity(count as _);
             for _ in 0..count {
                 v.push(Value::Double(data.read_f64()?))
             }
-            return Ok(Value::List(v));
+            Ok(Value::List(v))
         }
         Type::RATIONAL => {
             let mut v = Vec::with_capacity(count as _);
             for _ in 0..count {
                 v.push(Value::Rational(data.read_u32()?, data.read_u32()?))
             }
-            return Ok(Value::List(v));
+            Ok(Value::List(v))
         }
         Type::SRATIONAL => {
             let mut v = Vec::with_capacity(count as _);
             for _ in 0..count {
                 v.push(Value::SRational(data.read_i32()?, data.read_i32()?))
             }
-            return Ok(Value::List(v));
+            Ok(Value::List(v))
         }
         Type::LONG8 => {
             let mut v = Vec::with_capacity(count as _);
             for _ in 0..count {
                 v.push(Value::UnsignedBig(data.read_u64()?))
             }
-            return Ok(Value::List(v));
+            Ok(Value::List(v))
         }
         Type::SLONG8 => {
             let mut v = Vec::with_capacity(count as _);
             for _ in 0..count {
                 v.push(Value::SignedBig(data.read_i64()?))
             }
-            return Ok(Value::List(v));
+            Ok(Value::List(v))
         }
         Type::IFD => {
             let mut v = Vec::with_capacity(count as _);
             for _ in 0..count {
                 v.push(Value::Ifd(data.read_u32()?))
             }
-            return Ok(Value::List(v));
+            Ok(Value::List(v))
         }
         Type::IFD8 => {
             let mut v = Vec::with_capacity(count as _);
             for _ in 0..count {
                 v.push(Value::IfdBig(data.read_u64()?))
             }
-            return Ok(Value::List(v));
+            Ok(Value::List(v))
         }
     }
 }
diff --git a/src/reader.rs b/src/reader.rs
@@ -341,31 +341,37 @@ impl AsyncCursor {
     }
 
     /// Read a u8 from the cursor, advancing the internal state by 1 byte.
+    #[allow(dead_code)]
     pub(crate) async fn read_u8(&mut self) -> AsyncTiffResult<u8> {
         self.read(1).await?.read_u8()
     }
 
     /// Read a i8 from the cursor, advancing the internal state by 1 byte.
+    #[allow(dead_code)]
     pub(crate) async fn read_i8(&mut self) -> AsyncTiffResult<i8> {
         self.read(1).await?.read_i8()
     }
 
     /// Read a u16 from the cursor, advancing the internal state by 2 bytes.
+    #[allow(dead_code)]
     pub(crate) async fn read_u16(&mut self) -> AsyncTiffResult<u16> {
         self.read(2).await?.read_u16()
     }
 
     /// Read a i16 from the cursor, advancing the internal state by 2 bytes.
+    #[allow(dead_code)]
     pub(crate) async fn read_i16(&mut self) -> AsyncTiffResult<i16> {
         self.read(2).await?.read_i16()
     }
 
     /// Read a u32 from the cursor, advancing the internal state by 4 bytes.
+    #[allow(dead_code)]
     pub(crate) async fn read_u32(&mut self) -> AsyncTiffResult<u32> {
         self.read(4).await?.read_u32()
     }
 
     /// Read a i32 from the cursor, advancing the internal state by 4 bytes.
+    #[allow(dead_code)]
     pub(crate) async fn read_i32(&mut self) -> AsyncTiffResult<i32> {
         self.read(4).await?.read_i32()
     }
@@ -376,24 +382,25 @@ impl AsyncCursor {
     }
 
     /// Read a i64 from the cursor, advancing the internal state by 8 bytes.
+    #[allow(dead_code)]
     pub(crate) async fn read_i64(&mut self) -> AsyncTiffResult<i64> {
         self.read(8).await?.read_i64()
     }
 
+    #[allow(dead_code)]
     pub(crate) async fn read_f32(&mut self) -> AsyncTiffResult<f32> {
         self.read(4).await?.read_f32()
     }
 
+    #[allow(dead_code)]
     pub(crate) async fn read_f64(&mut self) -> AsyncTiffResult<f64> {
         self.read(8).await?.read_f64()
     }
 
-    #[allow(dead_code)]
     pub(crate) fn reader(&self) -> &Arc<dyn AsyncFileReader> {
         &self.reader
     }
 
-    #[allow(dead_code)]
     pub(crate) fn endianness(&self) -> Endianness {
         self.endianness
     }
@@ -407,6 +414,7 @@ impl AsyncCursor {
         self.offset = offset;
     }
 
+    #[allow(dead_code)]
     pub(crate) fn position(&self) -> u64 {
         self.offset
     }

Original file line number	Diff line number	Diff line change
`@@ -887,9 +887,9 @@ async fn read_tag_value(`
`887`	`887`	`// value fits in offset field`
`888`	`888`	`let res = cursor.read(value_byte_length).await?;`
`889`	`889`	`if bigtiff {`
`890`		`- cursor.advance(8-value_byte_length);`
	`890`	`+ cursor.advance(8 - value_byte_length);`
`891`	`891`	`} else {`
`892`		`- cursor.advance(4-value_byte_length);`
	`892`	`+ cursor.advance(4 - value_byte_length);`
`893`	`893`	`}`
`894`	`894`	`res`
`895`	`895`	`} else {`
`@@ -899,7 +899,11 @@ async fn read_tag_value(`
`899`	`899`	`} else {`
`900`	`900`	`cursor.read_u32().await?.into()`
`901`	`901`	`};`
`902`		`- let reader = cursor.reader().get_bytes(offset..offset+value_byte_length).await?.reader();`
	`902`	`+ let reader = cursor`
	`903`	`+ .reader()`
	`904`	`+ .get_bytes(offset..offset + value_byte_length)`
	`905`	`+ .await?`
	`906`	`+ .reader();`
`903`	`907`	`EndianAwareReader::new(reader, cursor.endianness())`
`904`	`908`	`// cursor.seek(offset);`
`905`	`909`	`// cursor.read(value_byte_length).await?`
`@@ -934,18 +938,18 @@ async fn read_tag_value(`
`934`	`938`
`935`	`939`	`match tag_type {`
`936`	`940`	`Type::BYTE \| Type::UNDEFINED => {`
`937`		`- let mut v = Vec::new();`
	`941`	`+ let mut v = Vec::with_capacity(count as _);`
`938`	`942`	`for _ in 0..count {`
`939`	`943`	`v.push(Value::Byte(data.read_u8()?));`
`940`	`944`	`}`
`941`		`- return Ok(Value::List(v));`
	`945`	`+ Ok(Value::List(v))`
`942`	`946`	`}`
`943`	`947`	`Type::SBYTE => {`
`944`		`- let mut v = Vec::new();`
	`948`	`+ let mut v = Vec::with_capacity(count as _);`
`945`	`949`	`for _ in 0..count {`
`946`	`950`	`v.push(Value::SignedByte(data.read_i8()?));`
`947`	`951`	`}`
`948`		`- return Ok(Value::List(v));`
	`952`	`+ Ok(Value::List(v))`
`949`	`953`	`}`
`950`	`954`	`Type::ASCII => {`
`951`	`955`	`let mut buf = vec![0; count as usize];`
`@@ -954,95 +958,95 @@ async fn read_tag_value(`
`954`	`958`	`let v = std::str::from_utf8(&buf)`
`955`	`959`	`.map_err(\|err\| AsyncTiffError::General(err.to_string()))?;`
`956`	`960`	`let v = v.trim_matches(char::from(0));`
`957`		`- return Ok(Value::Ascii(v.into()));`
	`961`	`+ Ok(Value::Ascii(v.into()))`
`958`	`962`	`} else {`
`959`	`963`	`panic!("Invalid tag");`
`960`	`964`	`// return Err(TiffError::FormatError(TiffFormatError::InvalidTag));`
`961`	`965`	`}`
`962`	`966`	`}`
`963`	`967`	`Type::SHORT => {`
`964`		`- let mut v = Vec::new();`
	`968`	`+ let mut v = Vec::with_capacity(count as _);`
`965`	`969`	`for _ in 0..count {`
`966`	`970`	`v.push(Value::Short(data.read_u16()?));`
`967`	`971`	`}`
`968`		`- return Ok(Value::List(v));`
	`972`	`+ Ok(Value::List(v))`
`969`	`973`	`}`
`970`	`974`	`Type::SSHORT => {`
`971`		`- let mut v = Vec::new();`
	`975`	`+ let mut v = Vec::with_capacity(count as _);`
`972`	`976`	`for _ in 0..count {`
`973`	`977`	`v.push(Value::Signed(i32::from(data.read_i16()?)));`
`974`	`978`	`}`
`975`		`- return Ok(Value::List(v));`
	`979`	`+ Ok(Value::List(v))`
`976`	`980`	`}`
`977`	`981`	`Type::LONG => {`
`978`		`- let mut v = Vec::new();`
	`982`	`+ let mut v = Vec::with_capacity(count as _);`
`979`	`983`	`for _ in 0..count {`
`980`	`984`	`v.push(Value::Unsigned(data.read_u32()?));`
`981`	`985`	`}`
`982`		`- return Ok(Value::List(v));`
	`986`	`+ Ok(Value::List(v))`
`983`	`987`	`}`
`984`	`988`	`Type::SLONG => {`
`985`		`- let mut v = Vec::new();`
	`989`	`+ let mut v = Vec::with_capacity(count as _);`
`986`	`990`	`for _ in 0..count {`
`987`	`991`	`v.push(Value::Signed(data.read_i32()?));`
`988`	`992`	`}`
`989`		`- return Ok(Value::List(v));`
	`993`	`+ Ok(Value::List(v))`
`990`	`994`	`}`
`991`	`995`	`Type::FLOAT => {`
`992`		`- let mut v = Vec::new();`
	`996`	`+ let mut v = Vec::with_capacity(count as _);`
`993`	`997`	`for _ in 0..count {`
`994`	`998`	`v.push(Value::Float(data.read_f32()?));`
`995`	`999`	`}`
`996`		`- return Ok(Value::List(v));`
	`1000`	`+ Ok(Value::List(v))`
`997`	`1001`	`}`
`998`	`1002`	`Type::DOUBLE => {`
`999`	`1003`	`let mut v = Vec::with_capacity(count as _);`
`1000`	`1004`	`for _ in 0..count {`
`1001`	`1005`	`v.push(Value::Double(data.read_f64()?))`
`1002`	`1006`	`}`
`1003`		`- return Ok(Value::List(v));`
	`1007`	`+ Ok(Value::List(v))`
`1004`	`1008`	`}`
`1005`	`1009`	`Type::RATIONAL => {`
`1006`	`1010`	`let mut v = Vec::with_capacity(count as _);`
`1007`	`1011`	`for _ in 0..count {`
`1008`	`1012`	`v.push(Value::Rational(data.read_u32()?, data.read_u32()?))`
`1009`	`1013`	`}`
`1010`		`- return Ok(Value::List(v));`
	`1014`	`+ Ok(Value::List(v))`
`1011`	`1015`	`}`
`1012`	`1016`	`Type::SRATIONAL => {`
`1013`	`1017`	`let mut v = Vec::with_capacity(count as _);`
`1014`	`1018`	`for _ in 0..count {`
`1015`	`1019`	`v.push(Value::SRational(data.read_i32()?, data.read_i32()?))`
`1016`	`1020`	`}`
`1017`		`- return Ok(Value::List(v));`
	`1021`	`+ Ok(Value::List(v))`
`1018`	`1022`	`}`
`1019`	`1023`	`Type::LONG8 => {`
`1020`	`1024`	`let mut v = Vec::with_capacity(count as _);`
`1021`	`1025`	`for _ in 0..count {`
`1022`	`1026`	`v.push(Value::UnsignedBig(data.read_u64()?))`
`1023`	`1027`	`}`
`1024`		`- return Ok(Value::List(v));`
	`1028`	`+ Ok(Value::List(v))`
`1025`	`1029`	`}`
`1026`	`1030`	`Type::SLONG8 => {`
`1027`	`1031`	`let mut v = Vec::with_capacity(count as _);`
`1028`	`1032`	`for _ in 0..count {`
`1029`	`1033`	`v.push(Value::SignedBig(data.read_i64()?))`
`1030`	`1034`	`}`
`1031`		`- return Ok(Value::List(v));`
	`1035`	`+ Ok(Value::List(v))`
`1032`	`1036`	`}`
`1033`	`1037`	`Type::IFD => {`
`1034`	`1038`	`let mut v = Vec::with_capacity(count as _);`
`1035`	`1039`	`for _ in 0..count {`
`1036`	`1040`	`v.push(Value::Ifd(data.read_u32()?))`
`1037`	`1041`	`}`
`1038`		`- return Ok(Value::List(v));`
	`1042`	`+ Ok(Value::List(v))`
`1039`	`1043`	`}`
`1040`	`1044`	`Type::IFD8 => {`
`1041`	`1045`	`let mut v = Vec::with_capacity(count as _);`
`1042`	`1046`	`for _ in 0..count {`
`1043`	`1047`	`v.push(Value::IfdBig(data.read_u64()?))`
`1044`	`1048`	`}`
`1045`		`- return Ok(Value::List(v));`
	`1049`	`+ Ok(Value::List(v))`
`1046`	`1050`	`}`
`1047`	`1051`	`}`
`1048`	`1052`	`}`
Original file line number	Diff line number	Diff line change
`@@ -341,31 +341,37 @@ impl AsyncCursor {`
`341`	`341`	`}`
`342`	`342`
`343`	`343`	`/// Read a u8 from the cursor, advancing the internal state by 1 byte.`
	`344`	`+ #[allow(dead_code)]`
`344`	`345`	`pub(crate) async fn read_u8(&mut self) -> AsyncTiffResult<u8> {`
`345`	`346`	`self.read(1).await?.read_u8()`
`346`	`347`	`}`
`347`	`348`
`348`	`349`	`/// Read a i8 from the cursor, advancing the internal state by 1 byte.`
	`350`	`+ #[allow(dead_code)]`
`349`	`351`	`pub(crate) async fn read_i8(&mut self) -> AsyncTiffResult<i8> {`
`350`	`352`	`self.read(1).await?.read_i8()`
`351`	`353`	`}`
`352`	`354`
`353`	`355`	`/// Read a u16 from the cursor, advancing the internal state by 2 bytes.`
	`356`	`+ #[allow(dead_code)]`
`354`	`357`	`pub(crate) async fn read_u16(&mut self) -> AsyncTiffResult<u16> {`
`355`	`358`	`self.read(2).await?.read_u16()`
`356`	`359`	`}`
`357`	`360`
`358`	`361`	`/// Read a i16 from the cursor, advancing the internal state by 2 bytes.`
	`362`	`+ #[allow(dead_code)]`
`359`	`363`	`pub(crate) async fn read_i16(&mut self) -> AsyncTiffResult<i16> {`
`360`	`364`	`self.read(2).await?.read_i16()`
`361`	`365`	`}`
`362`	`366`
`363`	`367`	`/// Read a u32 from the cursor, advancing the internal state by 4 bytes.`
	`368`	`+ #[allow(dead_code)]`
`364`	`369`	`pub(crate) async fn read_u32(&mut self) -> AsyncTiffResult<u32> {`
`365`	`370`	`self.read(4).await?.read_u32()`
`366`	`371`	`}`
`367`	`372`
`368`	`373`	`/// Read a i32 from the cursor, advancing the internal state by 4 bytes.`
	`374`	`+ #[allow(dead_code)]`
`369`	`375`	`pub(crate) async fn read_i32(&mut self) -> AsyncTiffResult<i32> {`
`370`	`376`	`self.read(4).await?.read_i32()`
`371`	`377`	`}`
`@@ -376,24 +382,25 @@ impl AsyncCursor {`
`376`	`382`	`}`
`377`	`383`
`378`	`384`	`/// Read a i64 from the cursor, advancing the internal state by 8 bytes.`
	`385`	`+ #[allow(dead_code)]`
`379`	`386`	`pub(crate) async fn read_i64(&mut self) -> AsyncTiffResult<i64> {`
`380`	`387`	`self.read(8).await?.read_i64()`
`381`	`388`	`}`
`382`	`389`
	`390`	`+ #[allow(dead_code)]`
`383`	`391`	`pub(crate) async fn read_f32(&mut self) -> AsyncTiffResult<f32> {`
`384`	`392`	`self.read(4).await?.read_f32()`
`385`	`393`	`}`
`386`	`394`
	`395`	`+ #[allow(dead_code)]`
`387`	`396`	`pub(crate) async fn read_f64(&mut self) -> AsyncTiffResult<f64> {`
`388`	`397`	`self.read(8).await?.read_f64()`
`389`	`398`	`}`
`390`	`399`
`391`		`- #[allow(dead_code)]`
`392`	`400`	`pub(crate) fn reader(&self) -> &Arc<dyn AsyncFileReader> {`
`393`	`401`	`&self.reader`
`394`	`402`	`}`
`395`	`403`
`396`		`- #[allow(dead_code)]`
`397`	`404`	`pub(crate) fn endianness(&self) -> Endianness {`
`398`	`405`	`self.endianness`
`399`	`406`	`}`
`@@ -407,6 +414,7 @@ impl AsyncCursor {`
`407`	`414`	`self.offset = offset;`
`408`	`415`	`}`
`409`	`416`
	`417`	`+ #[allow(dead_code)]`
`410`	`418`	`pub(crate) fn position(&self) -> u64 {`
`411`	`419`	`self.offset`
`412`	`420`	`}`