Merge pull request #290 from jakubadamw/nightly-compilation-warnings

197g · web-flow · commit 50be15e3565a · 2025-08-14T16:50:22.000Z
Address compilation warnings in the Nightly channel of Rust
diff --git a/src/decoder/mod.rs b/src/decoder/mod.rs
@@ -138,7 +138,7 @@ impl DecodingResult {
         }
     }
 
-    pub fn as_buffer(&mut self, start: usize) -> DecodingBuffer {
+    pub fn as_buffer(&mut self, start: usize) -> DecodingBuffer<'_> {
         match *self {
             DecodingResult::U8(ref mut buf) => DecodingBuffer::U8(&mut buf[start..]),
             DecodingResult::U16(ref mut buf) => DecodingBuffer::U16(&mut buf[start..]),
diff --git a/src/encoder/mod.rs b/src/encoder/mod.rs
@@ -198,7 +198,7 @@ impl<W: Write + Seek, K: TiffKind> TiffEncoder<W, K> {
         &mut self,
         width: u32,
         height: u32,
-    ) -> TiffResult<ImageEncoder<W, C, K>> {
+    ) -> TiffResult<ImageEncoder<'_, W, C, K>> {
         let encoder = Self::chain_directory(&mut self.writer, &mut self.last_ifd_chain)?;
         ImageEncoder::new(encoder, width, height, self.compression, self.predictor)
     }
diff --git a/src/encoder/tiff_value.rs b/src/encoder/tiff_value.rs
@@ -15,7 +15,7 @@ pub trait TiffValue {
 
     /// Access this value as an contiguous sequence of bytes.
     /// If their is no trivial representation, allocate it on the heap.
-    fn data(&self) -> Cow<[u8]>;
+    fn data(&self) -> Cow<'_, [u8]>;
 
     /// Write this value to a TiffWriter.
     /// While the default implementation will work in all cases, it may require unnecessary allocations.
@@ -34,7 +34,7 @@ impl TiffValue for [u8] {
         self.len()
     }
 
-    fn data(&self) -> Cow<[u8]> {
+    fn data(&self) -> Cow<'_, [u8]> {
         Cow::Borrowed(self)
     }
 }
@@ -47,7 +47,7 @@ impl TiffValue for [i8] {
         self.len()
     }
 
-    fn data(&self) -> Cow<[u8]> {
+    fn data(&self) -> Cow<'_, [u8]> {
         Cow::Borrowed(bytecast::i8_as_ne_bytes(self))
     }
 }
@@ -60,7 +60,7 @@ impl TiffValue for [u16] {
         self.len()
     }
 
-    fn data(&self) -> Cow<[u8]> {
+    fn data(&self) -> Cow<'_, [u8]> {
         Cow::Borrowed(bytecast::u16_as_ne_bytes(self))
     }
 }
@@ -73,7 +73,7 @@ impl TiffValue for [i16] {
         self.len()
     }
 
-    fn data(&self) -> Cow<[u8]> {
+    fn data(&self) -> Cow<'_, [u8]> {
         Cow::Borrowed(bytecast::i16_as_ne_bytes(self))
     }
 }
@@ -86,7 +86,7 @@ impl TiffValue for [u32] {
         self.len()
     }
 
-    fn data(&self) -> Cow<[u8]> {
+    fn data(&self) -> Cow<'_, [u8]> {
         Cow::Borrowed(bytecast::u32_as_ne_bytes(self))
     }
 }
@@ -99,7 +99,7 @@ impl TiffValue for [i32] {
         self.len()
     }
 
-    fn data(&self) -> Cow<[u8]> {
+    fn data(&self) -> Cow<'_, [u8]> {
         Cow::Borrowed(bytecast::i32_as_ne_bytes(self))
     }
 }
@@ -112,7 +112,7 @@ impl TiffValue for [u64] {
         self.len()
     }
 
-    fn data(&self) -> Cow<[u8]> {
+    fn data(&self) -> Cow<'_, [u8]> {
         Cow::Borrowed(bytecast::u64_as_ne_bytes(self))
     }
 }
@@ -125,7 +125,7 @@ impl TiffValue for [i64] {
         self.len()
     }
 
-    fn data(&self) -> Cow<[u8]> {
+    fn data(&self) -> Cow<'_, [u8]> {
         Cow::Borrowed(bytecast::i64_as_ne_bytes(self))
     }
 }
@@ -138,7 +138,7 @@ impl TiffValue for [f32] {
         self.len()
     }
 
-    fn data(&self) -> Cow<[u8]> {
+    fn data(&self) -> Cow<'_, [u8]> {
         // We write using native endian so this should be safe
         Cow::Borrowed(bytecast::f32_as_ne_bytes(self))
     }
@@ -152,7 +152,7 @@ impl TiffValue for [f64] {
         self.len()
     }
 
-    fn data(&self) -> Cow<[u8]> {
+    fn data(&self) -> Cow<'_, [u8]> {
         // We write using native endian so this should be safe
         Cow::Borrowed(bytecast::f64_as_ne_bytes(self))
     }
@@ -171,7 +171,7 @@ impl TiffValue for u8 {
         Ok(())
     }
 
-    fn data(&self) -> Cow<[u8]> {
+    fn data(&self) -> Cow<'_, [u8]> {
         Cow::Borrowed(from_ref(self))
     }
 }
@@ -189,7 +189,7 @@ impl TiffValue for i8 {
         Ok(())
     }
 
-    fn data(&self) -> Cow<[u8]> {
+    fn data(&self) -> Cow<'_, [u8]> {
         Cow::Borrowed(bytecast::i8_as_ne_bytes(from_ref(self)))
     }
 }
@@ -207,7 +207,7 @@ impl TiffValue for u16 {
         Ok(())
     }
 
-    fn data(&self) -> Cow<[u8]> {
+    fn data(&self) -> Cow<'_, [u8]> {
         Cow::Borrowed(bytecast::u16_as_ne_bytes(from_ref(self)))
     }
 }
@@ -225,7 +225,7 @@ impl TiffValue for i16 {
         Ok(())
     }
 
-    fn data(&self) -> Cow<[u8]> {
+    fn data(&self) -> Cow<'_, [u8]> {
         Cow::Borrowed(bytecast::i16_as_ne_bytes(from_ref(self)))
     }
 }
@@ -243,7 +243,7 @@ impl TiffValue for u32 {
         Ok(())
     }
 
-    fn data(&self) -> Cow<[u8]> {
+    fn data(&self) -> Cow<'_, [u8]> {
         Cow::Borrowed(bytecast::u32_as_ne_bytes(from_ref(self)))
     }
 }
@@ -261,7 +261,7 @@ impl TiffValue for i32 {
         Ok(())
     }
 
-    fn data(&self) -> Cow<[u8]> {
+    fn data(&self) -> Cow<'_, [u8]> {
         Cow::Borrowed(bytecast::i32_as_ne_bytes(from_ref(self)))
     }
 }
@@ -279,7 +279,7 @@ impl TiffValue for u64 {
         Ok(())
     }
 
-    fn data(&self) -> Cow<[u8]> {
+    fn data(&self) -> Cow<'_, [u8]> {
         Cow::Borrowed(bytecast::u64_as_ne_bytes(from_ref(self)))
     }
 }
@@ -297,7 +297,7 @@ impl TiffValue for i64 {
         Ok(())
     }
 
-    fn data(&self) -> Cow<[u8]> {
+    fn data(&self) -> Cow<'_, [u8]> {
         Cow::Borrowed(bytecast::i64_as_ne_bytes(from_ref(self)))
     }
 }
@@ -315,7 +315,7 @@ impl TiffValue for f32 {
         Ok(())
     }
 
-    fn data(&self) -> Cow<[u8]> {
+    fn data(&self) -> Cow<'_, [u8]> {
         Cow::Borrowed(bytecast::f32_as_ne_bytes(from_ref(self)))
     }
 }
@@ -333,7 +333,7 @@ impl TiffValue for f64 {
         Ok(())
     }
 
-    fn data(&self) -> Cow<[u8]> {
+    fn data(&self) -> Cow<'_, [u8]> {
         Cow::Borrowed(bytecast::f64_as_ne_bytes(from_ref(self)))
     }
 }
@@ -351,7 +351,7 @@ impl TiffValue for Ifd {
         Ok(())
     }
 
-    fn data(&self) -> Cow<[u8]> {
+    fn data(&self) -> Cow<'_, [u8]> {
         Cow::Borrowed(bytecast::u32_as_ne_bytes(from_ref(&self.0)))
     }
 }
@@ -369,7 +369,7 @@ impl TiffValue for Ifd8 {
         Ok(())
     }
 
-    fn data(&self) -> Cow<[u8]> {
+    fn data(&self) -> Cow<'_, [u8]> {
         Cow::Borrowed(bytecast::u64_as_ne_bytes(from_ref(&self.0)))
     }
 }
@@ -388,7 +388,7 @@ impl TiffValue for Rational {
         Ok(())
     }
 
-    fn data(&self) -> Cow<[u8]> {
+    fn data(&self) -> Cow<'_, [u8]> {
         Cow::Owned({
             let first_dword = bytecast::u32_as_ne_bytes(from_ref(&self.n));
             let second_dword = bytecast::u32_as_ne_bytes(from_ref(&self.d));
@@ -411,7 +411,7 @@ impl TiffValue for SRational {
         Ok(())
     }
 
-    fn data(&self) -> Cow<[u8]> {
+    fn data(&self) -> Cow<'_, [u8]> {
         Cow::Owned({
             let first_dword = bytecast::i32_as_ne_bytes(from_ref(&self.n));
             let second_dword = bytecast::i32_as_ne_bytes(from_ref(&self.d));
@@ -438,7 +438,7 @@ impl TiffValue for str {
         }
     }
 
-    fn data(&self) -> Cow<[u8]> {
+    fn data(&self) -> Cow<'_, [u8]> {
         Cow::Owned({
             if self.is_ascii() && !self.bytes().any(|b| b == 0) {
                 let bytes: &[u8] = self.as_bytes();
@@ -462,7 +462,7 @@ impl<T: TiffValue + ?Sized> TiffValue for &'_ T {
         (*self).write(writer)
     }
 
-    fn data(&self) -> Cow<[u8]> {
+    fn data(&self) -> Cow<'_, [u8]> {
         T::data(self)
     }
 }
@@ -484,7 +484,7 @@ macro_rules! impl_tiff_value_for_contiguous_sequence {
                 Ok(())
             }
 
-            fn data(&self) -> Cow<[u8]> {
+            fn data(&self) -> Cow<'_, [u8]> {
                 let mut buf: Vec<u8> = Vec::with_capacity(Self::BYTE_LEN as usize * self.len());
                 for x in self {
                     buf.extend_from_slice(&x.data());

Original file line number	Diff line number	Diff line change
`@@ -138,7 +138,7 @@ impl DecodingResult {`
`138`	`138`	`}`
`139`	`139`	`}`
`140`	`140`
`141`		`- pub fn as_buffer(&mut self, start: usize) -> DecodingBuffer {`
	`141`	`+ pub fn as_buffer(&mut self, start: usize) -> DecodingBuffer<'_> {`
`142`	`142`	`match *self {`
`143`	`143`	`DecodingResult::U8(ref mut buf) => DecodingBuffer::U8(&mut buf[start..]),`
`144`	`144`	`DecodingResult::U16(ref mut buf) => DecodingBuffer::U16(&mut buf[start..]),`
Original file line number	Diff line number	Diff line change
`@@ -198,7 +198,7 @@ impl<W: Write + Seek, K: TiffKind> TiffEncoder<W, K> {`
`198`	`198`	`&mut self,`
`199`	`199`	`width: u32,`
`200`	`200`	`height: u32,`
`201`		`- ) -> TiffResult<ImageEncoder<W, C, K>> {`
	`201`	`+ ) -> TiffResult<ImageEncoder<'_, W, C, K>> {`
`202`	`202`	`let encoder = Self::chain_directory(&mut self.writer, &mut self.last_ifd_chain)?;`
`203`	`203`	`ImageEncoder::new(encoder, width, height, self.compression, self.predictor)`
`204`	`204`	`}`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ pub trait TiffValue {`
`15`	`15`
`16`	`16`	`/// Access this value as an contiguous sequence of bytes.`
`17`	`17`	`/// If their is no trivial representation, allocate it on the heap.`
`18`		`- fn data(&self) -> Cow<[u8]>;`
	`18`	`+ fn data(&self) -> Cow<'_, [u8]>;`
`19`	`19`
`20`	`20`	`/// Write this value to a TiffWriter.`
`21`	`21`	`/// While the default implementation will work in all cases, it may require unnecessary allocations.`
`@@ -34,7 +34,7 @@ impl TiffValue for [u8] {`
`34`	`34`	`self.len()`
`35`	`35`	`}`
`36`	`36`
`37`		`- fn data(&self) -> Cow<[u8]> {`
	`37`	`+ fn data(&self) -> Cow<'_, [u8]> {`
`38`	`38`	`Cow::Borrowed(self)`
`39`	`39`	`}`
`40`	`40`	`}`
`@@ -47,7 +47,7 @@ impl TiffValue for [i8] {`
`47`	`47`	`self.len()`
`48`	`48`	`}`
`49`	`49`
`50`		`- fn data(&self) -> Cow<[u8]> {`
	`50`	`+ fn data(&self) -> Cow<'_, [u8]> {`
`51`	`51`	`Cow::Borrowed(bytecast::i8_as_ne_bytes(self))`
`52`	`52`	`}`
`53`	`53`	`}`
`@@ -60,7 +60,7 @@ impl TiffValue for [u16] {`
`60`	`60`	`self.len()`
`61`	`61`	`}`
`62`	`62`
`63`		`- fn data(&self) -> Cow<[u8]> {`
	`63`	`+ fn data(&self) -> Cow<'_, [u8]> {`
`64`	`64`	`Cow::Borrowed(bytecast::u16_as_ne_bytes(self))`
`65`	`65`	`}`
`66`	`66`	`}`
`@@ -73,7 +73,7 @@ impl TiffValue for [i16] {`
`73`	`73`	`self.len()`
`74`	`74`	`}`
`75`	`75`
`76`		`- fn data(&self) -> Cow<[u8]> {`
	`76`	`+ fn data(&self) -> Cow<'_, [u8]> {`
`77`	`77`	`Cow::Borrowed(bytecast::i16_as_ne_bytes(self))`
`78`	`78`	`}`
`79`	`79`	`}`
`@@ -86,7 +86,7 @@ impl TiffValue for [u32] {`
`86`	`86`	`self.len()`
`87`	`87`	`}`
`88`	`88`
`89`		`- fn data(&self) -> Cow<[u8]> {`
	`89`	`+ fn data(&self) -> Cow<'_, [u8]> {`
`90`	`90`	`Cow::Borrowed(bytecast::u32_as_ne_bytes(self))`
`91`	`91`	`}`
`92`	`92`	`}`
`@@ -99,7 +99,7 @@ impl TiffValue for [i32] {`
`99`	`99`	`self.len()`
`100`	`100`	`}`
`101`	`101`
`102`		`- fn data(&self) -> Cow<[u8]> {`
	`102`	`+ fn data(&self) -> Cow<'_, [u8]> {`
`103`	`103`	`Cow::Borrowed(bytecast::i32_as_ne_bytes(self))`
`104`	`104`	`}`
`105`	`105`	`}`
`@@ -112,7 +112,7 @@ impl TiffValue for [u64] {`
`112`	`112`	`self.len()`
`113`	`113`	`}`
`114`	`114`
`115`		`- fn data(&self) -> Cow<[u8]> {`
	`115`	`+ fn data(&self) -> Cow<'_, [u8]> {`
`116`	`116`	`Cow::Borrowed(bytecast::u64_as_ne_bytes(self))`
`117`	`117`	`}`
`118`	`118`	`}`
`@@ -125,7 +125,7 @@ impl TiffValue for [i64] {`
`125`	`125`	`self.len()`
`126`	`126`	`}`
`127`	`127`
`128`		`- fn data(&self) -> Cow<[u8]> {`
	`128`	`+ fn data(&self) -> Cow<'_, [u8]> {`
`129`	`129`	`Cow::Borrowed(bytecast::i64_as_ne_bytes(self))`
`130`	`130`	`}`
`131`	`131`	`}`
`@@ -138,7 +138,7 @@ impl TiffValue for [f32] {`
`138`	`138`	`self.len()`
`139`	`139`	`}`
`140`	`140`
`141`		`- fn data(&self) -> Cow<[u8]> {`
	`141`	`+ fn data(&self) -> Cow<'_, [u8]> {`
`142`	`142`	`// We write using native endian so this should be safe`
`143`	`143`	`Cow::Borrowed(bytecast::f32_as_ne_bytes(self))`
`144`	`144`	`}`
`@@ -152,7 +152,7 @@ impl TiffValue for [f64] {`
`152`	`152`	`self.len()`
`153`	`153`	`}`
`154`	`154`
`155`		`- fn data(&self) -> Cow<[u8]> {`
	`155`	`+ fn data(&self) -> Cow<'_, [u8]> {`
`156`	`156`	`// We write using native endian so this should be safe`
`157`	`157`	`Cow::Borrowed(bytecast::f64_as_ne_bytes(self))`
`158`	`158`	`}`
`@@ -171,7 +171,7 @@ impl TiffValue for u8 {`
`171`	`171`	`Ok(())`
`172`	`172`	`}`
`173`	`173`
`174`		`- fn data(&self) -> Cow<[u8]> {`
	`174`	`+ fn data(&self) -> Cow<'_, [u8]> {`
`175`	`175`	`Cow::Borrowed(from_ref(self))`
`176`	`176`	`}`
`177`	`177`	`}`
`@@ -189,7 +189,7 @@ impl TiffValue for i8 {`
`189`	`189`	`Ok(())`
`190`	`190`	`}`
`191`	`191`
`192`		`- fn data(&self) -> Cow<[u8]> {`
	`192`	`+ fn data(&self) -> Cow<'_, [u8]> {`
`193`	`193`	`Cow::Borrowed(bytecast::i8_as_ne_bytes(from_ref(self)))`
`194`	`194`	`}`
`195`	`195`	`}`
`@@ -207,7 +207,7 @@ impl TiffValue for u16 {`
`207`	`207`	`Ok(())`
`208`	`208`	`}`
`209`	`209`
`210`		`- fn data(&self) -> Cow<[u8]> {`
	`210`	`+ fn data(&self) -> Cow<'_, [u8]> {`
`211`	`211`	`Cow::Borrowed(bytecast::u16_as_ne_bytes(from_ref(self)))`
`212`	`212`	`}`
`213`	`213`	`}`
`@@ -225,7 +225,7 @@ impl TiffValue for i16 {`
`225`	`225`	`Ok(())`
`226`	`226`	`}`
`227`	`227`
`228`		`- fn data(&self) -> Cow<[u8]> {`
	`228`	`+ fn data(&self) -> Cow<'_, [u8]> {`
`229`	`229`	`Cow::Borrowed(bytecast::i16_as_ne_bytes(from_ref(self)))`
`230`	`230`	`}`
`231`	`231`	`}`
`@@ -243,7 +243,7 @@ impl TiffValue for u32 {`
`243`	`243`	`Ok(())`
`244`	`244`	`}`
`245`	`245`
`246`		`- fn data(&self) -> Cow<[u8]> {`
	`246`	`+ fn data(&self) -> Cow<'_, [u8]> {`
`247`	`247`	`Cow::Borrowed(bytecast::u32_as_ne_bytes(from_ref(self)))`
`248`	`248`	`}`
`249`	`249`	`}`
`@@ -261,7 +261,7 @@ impl TiffValue for i32 {`
`261`	`261`	`Ok(())`
`262`	`262`	`}`
`263`	`263`
`264`		`- fn data(&self) -> Cow<[u8]> {`
	`264`	`+ fn data(&self) -> Cow<'_, [u8]> {`
`265`	`265`	`Cow::Borrowed(bytecast::i32_as_ne_bytes(from_ref(self)))`
`266`	`266`	`}`
`267`	`267`	`}`
`@@ -279,7 +279,7 @@ impl TiffValue for u64 {`
`279`	`279`	`Ok(())`
`280`	`280`	`}`
`281`	`281`
`282`		`- fn data(&self) -> Cow<[u8]> {`
	`282`	`+ fn data(&self) -> Cow<'_, [u8]> {`
`283`	`283`	`Cow::Borrowed(bytecast::u64_as_ne_bytes(from_ref(self)))`
`284`	`284`	`}`
`285`	`285`	`}`
`@@ -297,7 +297,7 @@ impl TiffValue for i64 {`
`297`	`297`	`Ok(())`
`298`	`298`	`}`
`299`	`299`
`300`		`- fn data(&self) -> Cow<[u8]> {`
	`300`	`+ fn data(&self) -> Cow<'_, [u8]> {`
`301`	`301`	`Cow::Borrowed(bytecast::i64_as_ne_bytes(from_ref(self)))`
`302`	`302`	`}`
`303`	`303`	`}`
`@@ -315,7 +315,7 @@ impl TiffValue for f32 {`
`315`	`315`	`Ok(())`
`316`	`316`	`}`
`317`	`317`
`318`		`- fn data(&self) -> Cow<[u8]> {`
	`318`	`+ fn data(&self) -> Cow<'_, [u8]> {`
`319`	`319`	`Cow::Borrowed(bytecast::f32_as_ne_bytes(from_ref(self)))`
`320`	`320`	`}`
`321`	`321`	`}`
`@@ -333,7 +333,7 @@ impl TiffValue for f64 {`
`333`	`333`	`Ok(())`
`334`	`334`	`}`
`335`	`335`
`336`		`- fn data(&self) -> Cow<[u8]> {`
	`336`	`+ fn data(&self) -> Cow<'_, [u8]> {`
`337`	`337`	`Cow::Borrowed(bytecast::f64_as_ne_bytes(from_ref(self)))`
`338`	`338`	`}`
`339`	`339`	`}`
`@@ -351,7 +351,7 @@ impl TiffValue for Ifd {`
`351`	`351`	`Ok(())`
`352`	`352`	`}`
`353`	`353`
`354`		`- fn data(&self) -> Cow<[u8]> {`
	`354`	`+ fn data(&self) -> Cow<'_, [u8]> {`
`355`	`355`	`Cow::Borrowed(bytecast::u32_as_ne_bytes(from_ref(&self.0)))`
`356`	`356`	`}`
`357`	`357`	`}`
`@@ -369,7 +369,7 @@ impl TiffValue for Ifd8 {`
`369`	`369`	`Ok(())`
`370`	`370`	`}`
`371`	`371`
`372`		`- fn data(&self) -> Cow<[u8]> {`
	`372`	`+ fn data(&self) -> Cow<'_, [u8]> {`
`373`	`373`	`Cow::Borrowed(bytecast::u64_as_ne_bytes(from_ref(&self.0)))`
`374`	`374`	`}`
`375`	`375`	`}`
`@@ -388,7 +388,7 @@ impl TiffValue for Rational {`
`388`	`388`	`Ok(())`
`389`	`389`	`}`
`390`	`390`
`391`		`- fn data(&self) -> Cow<[u8]> {`
	`391`	`+ fn data(&self) -> Cow<'_, [u8]> {`
`392`	`392`	`Cow::Owned({`
`393`	`393`	`let first_dword = bytecast::u32_as_ne_bytes(from_ref(&self.n));`
`394`	`394`	`let second_dword = bytecast::u32_as_ne_bytes(from_ref(&self.d));`
`@@ -411,7 +411,7 @@ impl TiffValue for SRational {`
`411`	`411`	`Ok(())`
`412`	`412`	`}`
`413`	`413`
`414`		`- fn data(&self) -> Cow<[u8]> {`
	`414`	`+ fn data(&self) -> Cow<'_, [u8]> {`
`415`	`415`	`Cow::Owned({`
`416`	`416`	`let first_dword = bytecast::i32_as_ne_bytes(from_ref(&self.n));`
`417`	`417`	`let second_dword = bytecast::i32_as_ne_bytes(from_ref(&self.d));`
`@@ -438,7 +438,7 @@ impl TiffValue for str {`
`438`	`438`	`}`
`439`	`439`	`}`
`440`	`440`
`441`		`- fn data(&self) -> Cow<[u8]> {`
	`441`	`+ fn data(&self) -> Cow<'_, [u8]> {`
`442`	`442`	`Cow::Owned({`
`443`	`443`	`if self.is_ascii() && !self.bytes().any(\|b\| b == 0) {`
`444`	`444`	`let bytes: &[u8] = self.as_bytes();`
`@@ -462,7 +462,7 @@ impl<T: TiffValue + ?Sized> TiffValue for &'_ T {`
`462`	`462`	`(*self).write(writer)`
`463`	`463`	`}`
`464`	`464`
`465`		`- fn data(&self) -> Cow<[u8]> {`
	`465`	`+ fn data(&self) -> Cow<'_, [u8]> {`
`466`	`466`	`T::data(self)`
`467`	`467`	`}`
`468`	`468`	`}`
`@@ -484,7 +484,7 @@ macro_rules! impl_tiff_value_for_contiguous_sequence {`
`484`	`484`	`Ok(())`
`485`	`485`	`}`
`486`	`486`
`487`		`- fn data(&self) -> Cow<[u8]> {`
	`487`	`+ fn data(&self) -> Cow<'_, [u8]> {`
`488`	`488`	`let mut buf: Vec<u8> = Vec::with_capacity(Self::BYTE_LEN as usize * self.len());`
`489`	`489`	`for x in self {`
`490`	`490`	`buf.extend_from_slice(&x.data());`