fixed clippy

feefladder · feefladder · commit ab6c6a341a1b · 2025-03-23T20:40:39.000+01:00
diff --git a/src/ifd.rs b/src/ifd.rs
@@ -934,18 +934,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 +954,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
@@ -272,31 +272,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()
     }
@@ -307,24 +313,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
     }
@@ -338,6 +345,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
`@@ -934,18 +934,18 @@ async fn read_tag_value(`
`934`	`934`
`935`	`935`	`match tag_type {`
`936`	`936`	`Type::BYTE \| Type::UNDEFINED => {`
`937`		`- let mut v = Vec::new();`
	`937`	`+ let mut v = Vec::with_capacity(count as _);`
`938`	`938`	`for _ in 0..count {`
`939`	`939`	`v.push(Value::Byte(data.read_u8()?));`
`940`	`940`	`}`
`941`		`- return Ok(Value::List(v));`
	`941`	`+ Ok(Value::List(v))`
`942`	`942`	`}`
`943`	`943`	`Type::SBYTE => {`
`944`		`- let mut v = Vec::new();`
	`944`	`+ let mut v = Vec::with_capacity(count as _);`
`945`	`945`	`for _ in 0..count {`
`946`	`946`	`v.push(Value::SignedByte(data.read_i8()?));`
`947`	`947`	`}`
`948`		`- return Ok(Value::List(v));`
	`948`	`+ Ok(Value::List(v))`
`949`	`949`	`}`
`950`	`950`	`Type::ASCII => {`
`951`	`951`	`let mut buf = vec![0; count as usize];`
`@@ -954,95 +954,95 @@ async fn read_tag_value(`
`954`	`954`	`let v = std::str::from_utf8(&buf)`
`955`	`955`	`.map_err(\|err\| AsyncTiffError::General(err.to_string()))?;`
`956`	`956`	`let v = v.trim_matches(char::from(0));`
`957`		`- return Ok(Value::Ascii(v.into()));`
	`957`	`+ Ok(Value::Ascii(v.into()))`
`958`	`958`	`} else {`
`959`	`959`	`panic!("Invalid tag");`
`960`	`960`	`// return Err(TiffError::FormatError(TiffFormatError::InvalidTag));`
`961`	`961`	`}`
`962`	`962`	`}`
`963`	`963`	`Type::SHORT => {`
`964`		`- let mut v = Vec::new();`
	`964`	`+ let mut v = Vec::with_capacity(count as _);`
`965`	`965`	`for _ in 0..count {`
`966`	`966`	`v.push(Value::Short(data.read_u16()?));`
`967`	`967`	`}`
`968`		`- return Ok(Value::List(v));`
	`968`	`+ Ok(Value::List(v))`
`969`	`969`	`}`
`970`	`970`	`Type::SSHORT => {`
`971`		`- let mut v = Vec::new();`
	`971`	`+ let mut v = Vec::with_capacity(count as _);`
`972`	`972`	`for _ in 0..count {`
`973`	`973`	`v.push(Value::Signed(i32::from(data.read_i16()?)));`
`974`	`974`	`}`
`975`		`- return Ok(Value::List(v));`
	`975`	`+ Ok(Value::List(v))`
`976`	`976`	`}`
`977`	`977`	`Type::LONG => {`
`978`		`- let mut v = Vec::new();`
	`978`	`+ let mut v = Vec::with_capacity(count as _);`
`979`	`979`	`for _ in 0..count {`
`980`	`980`	`v.push(Value::Unsigned(data.read_u32()?));`
`981`	`981`	`}`
`982`		`- return Ok(Value::List(v));`
	`982`	`+ Ok(Value::List(v))`
`983`	`983`	`}`
`984`	`984`	`Type::SLONG => {`
`985`		`- let mut v = Vec::new();`
	`985`	`+ let mut v = Vec::with_capacity(count as _);`
`986`	`986`	`for _ in 0..count {`
`987`	`987`	`v.push(Value::Signed(data.read_i32()?));`
`988`	`988`	`}`
`989`		`- return Ok(Value::List(v));`
	`989`	`+ Ok(Value::List(v))`
`990`	`990`	`}`
`991`	`991`	`Type::FLOAT => {`
`992`		`- let mut v = Vec::new();`
	`992`	`+ let mut v = Vec::with_capacity(count as _);`
`993`	`993`	`for _ in 0..count {`
`994`	`994`	`v.push(Value::Float(data.read_f32()?));`
`995`	`995`	`}`
`996`		`- return Ok(Value::List(v));`
	`996`	`+ Ok(Value::List(v))`
`997`	`997`	`}`
`998`	`998`	`Type::DOUBLE => {`
`999`	`999`	`let mut v = Vec::with_capacity(count as _);`
`1000`	`1000`	`for _ in 0..count {`
`1001`	`1001`	`v.push(Value::Double(data.read_f64()?))`
`1002`	`1002`	`}`
`1003`		`- return Ok(Value::List(v));`
	`1003`	`+ Ok(Value::List(v))`
`1004`	`1004`	`}`
`1005`	`1005`	`Type::RATIONAL => {`
`1006`	`1006`	`let mut v = Vec::with_capacity(count as _);`
`1007`	`1007`	`for _ in 0..count {`
`1008`	`1008`	`v.push(Value::Rational(data.read_u32()?, data.read_u32()?))`
`1009`	`1009`	`}`
`1010`		`- return Ok(Value::List(v));`
	`1010`	`+ Ok(Value::List(v))`
`1011`	`1011`	`}`
`1012`	`1012`	`Type::SRATIONAL => {`
`1013`	`1013`	`let mut v = Vec::with_capacity(count as _);`
`1014`	`1014`	`for _ in 0..count {`
`1015`	`1015`	`v.push(Value::SRational(data.read_i32()?, data.read_i32()?))`
`1016`	`1016`	`}`
`1017`		`- return Ok(Value::List(v));`
	`1017`	`+ Ok(Value::List(v))`
`1018`	`1018`	`}`
`1019`	`1019`	`Type::LONG8 => {`
`1020`	`1020`	`let mut v = Vec::with_capacity(count as _);`
`1021`	`1021`	`for _ in 0..count {`
`1022`	`1022`	`v.push(Value::UnsignedBig(data.read_u64()?))`
`1023`	`1023`	`}`
`1024`		`- return Ok(Value::List(v));`
	`1024`	`+ Ok(Value::List(v))`
`1025`	`1025`	`}`
`1026`	`1026`	`Type::SLONG8 => {`
`1027`	`1027`	`let mut v = Vec::with_capacity(count as _);`
`1028`	`1028`	`for _ in 0..count {`
`1029`	`1029`	`v.push(Value::SignedBig(data.read_i64()?))`
`1030`	`1030`	`}`
`1031`		`- return Ok(Value::List(v));`
	`1031`	`+ Ok(Value::List(v))`
`1032`	`1032`	`}`
`1033`	`1033`	`Type::IFD => {`
`1034`	`1034`	`let mut v = Vec::with_capacity(count as _);`
`1035`	`1035`	`for _ in 0..count {`
`1036`	`1036`	`v.push(Value::Ifd(data.read_u32()?))`
`1037`	`1037`	`}`
`1038`		`- return Ok(Value::List(v));`
	`1038`	`+ Ok(Value::List(v))`
`1039`	`1039`	`}`
`1040`	`1040`	`Type::IFD8 => {`
`1041`	`1041`	`let mut v = Vec::with_capacity(count as _);`
`1042`	`1042`	`for _ in 0..count {`
`1043`	`1043`	`v.push(Value::IfdBig(data.read_u64()?))`
`1044`	`1044`	`}`
`1045`		`- return Ok(Value::List(v));`
	`1045`	`+ Ok(Value::List(v))`
`1046`	`1046`	`}`
`1047`	`1047`	`}`
`1048`	`1048`	`}`
Original file line number	Diff line number	Diff line change
`@@ -272,31 +272,37 @@ impl AsyncCursor {`
`272`	`272`	`}`
`273`	`273`
`274`	`274`	`/// Read a u8 from the cursor, advancing the internal state by 1 byte.`
	`275`	`+ #[allow(dead_code)]`
`275`	`276`	`pub(crate) async fn read_u8(&mut self) -> AsyncTiffResult<u8> {`
`276`	`277`	`self.read(1).await?.read_u8()`
`277`	`278`	`}`
`278`	`279`
`279`	`280`	`/// Read a i8 from the cursor, advancing the internal state by 1 byte.`
	`281`	`+ #[allow(dead_code)]`
`280`	`282`	`pub(crate) async fn read_i8(&mut self) -> AsyncTiffResult<i8> {`
`281`	`283`	`self.read(1).await?.read_i8()`
`282`	`284`	`}`
`283`	`285`
`284`	`286`	`/// Read a u16 from the cursor, advancing the internal state by 2 bytes.`
	`287`	`+ #[allow(dead_code)]`
`285`	`288`	`pub(crate) async fn read_u16(&mut self) -> AsyncTiffResult<u16> {`
`286`	`289`	`self.read(2).await?.read_u16()`
`287`	`290`	`}`
`288`	`291`
`289`	`292`	`/// Read a i16 from the cursor, advancing the internal state by 2 bytes.`
	`293`	`+ #[allow(dead_code)]`
`290`	`294`	`pub(crate) async fn read_i16(&mut self) -> AsyncTiffResult<i16> {`
`291`	`295`	`self.read(2).await?.read_i16()`
`292`	`296`	`}`
`293`	`297`
`294`	`298`	`/// Read a u32 from the cursor, advancing the internal state by 4 bytes.`
	`299`	`+ #[allow(dead_code)]`
`295`	`300`	`pub(crate) async fn read_u32(&mut self) -> AsyncTiffResult<u32> {`
`296`	`301`	`self.read(4).await?.read_u32()`
`297`	`302`	`}`
`298`	`303`
`299`	`304`	`/// Read a i32 from the cursor, advancing the internal state by 4 bytes.`
	`305`	`+ #[allow(dead_code)]`
`300`	`306`	`pub(crate) async fn read_i32(&mut self) -> AsyncTiffResult<i32> {`
`301`	`307`	`self.read(4).await?.read_i32()`
`302`	`308`	`}`
`@@ -307,24 +313,25 @@ impl AsyncCursor {`
`307`	`313`	`}`
`308`	`314`
`309`	`315`	`/// Read a i64 from the cursor, advancing the internal state by 8 bytes.`
	`316`	`+ #[allow(dead_code)]`
`310`	`317`	`pub(crate) async fn read_i64(&mut self) -> AsyncTiffResult<i64> {`
`311`	`318`	`self.read(8).await?.read_i64()`
`312`	`319`	`}`
`313`	`320`
	`321`	`+ #[allow(dead_code)]`
`314`	`322`	`pub(crate) async fn read_f32(&mut self) -> AsyncTiffResult<f32> {`
`315`	`323`	`self.read(4).await?.read_f32()`
`316`	`324`	`}`
`317`	`325`
	`326`	`+ #[allow(dead_code)]`
`318`	`327`	`pub(crate) async fn read_f64(&mut self) -> AsyncTiffResult<f64> {`
`319`	`328`	`self.read(8).await?.read_f64()`
`320`	`329`	`}`
`321`	`330`
`322`		`- #[allow(dead_code)]`
`323`	`331`	`pub(crate) fn reader(&self) -> &Arc<dyn AsyncFileReader> {`
`324`	`332`	`&self.reader`
`325`	`333`	`}`
`326`	`334`
`327`		`- #[allow(dead_code)]`
`328`	`335`	`pub(crate) fn endianness(&self) -> Endianness {`
`329`	`336`	`self.endianness`
`330`	`337`	`}`
`@@ -338,6 +345,7 @@ impl AsyncCursor {`
`338`	`345`	`self.offset = offset;`
`339`	`346`	`}`
`340`	`347`
	`348`	`+ #[allow(dead_code)]`
`341`	`349`	`pub(crate) fn position(&self) -> u64 {`
`342`	`350`	`self.offset`
`343`	`351`	`}`