Implement BinWrite for PosValue<T>

binrw/src/pos_value.rs

@@ -1,10 +1,11 @@
 use crate::{
     io::{Read, Seek},
-    BinRead, BinResult, Endian,
+    BinRead, BinResult, BinWrite, Endian,
 };
 use core::fmt;
 
 /// A wrapper that stores a value’s position alongside the value.
+/// Serializing a PosValue will ignore the `pos` field.
 ///
 /// # Examples
 ///
@@ -46,6 +47,19 @@ impl<T: BinRead> BinRead for PosValue<T> {
     }
 }
 
+impl<T: BinWrite> BinWrite for PosValue<T> {
+    type Args<'a> = T::Args<'a>;
+
+    fn write_options<W: std::io::Write + Seek>(
+        &self,
+        writer: &mut W,
+        endian: Endian,
+        args: Self::Args<'_>,
+    ) -> BinResult<()> {
+        self.val.write_options(writer, endian, args)
+    }
+}
+
 impl<T> core::ops::Deref for PosValue<T> {
     type Target = T;
 

binrw/tests/pos_value.rs

@@ -1,17 +1,17 @@
 extern crate alloc;
 
 use alloc::format;
-use binrw::{io::Cursor, BinRead, BinReaderExt, PosValue};
+use binrw::{io::Cursor, BinRead, BinReaderExt, BinWrite, PosValue};
 
 #[test]
 fn pos_value() {
-    #[derive(BinRead)]
+    #[derive(BinRead, BinWrite)]
     struct MyType {
         a: u16,
         b: PosValue<u8>,
     }
 
-    let mut val = Cursor::new(b"\xFF\xFE\xFD").read_be::<MyType>().unwrap();
+    let mut val: MyType = Cursor::new(b"\xFF\xFE\xFD").read_be::<MyType>().unwrap();
     assert_eq!(val.a, 0xFFFE);
     assert_eq!(val.b.pos, 2);
     assert_eq!(*val.b, 0xFD);
@@ -23,4 +23,9 @@ fn pos_value() {
     let clone = val.b.clone();
     assert_eq!(*clone, *val.b);
     assert_eq!(clone.pos, val.b.pos);
+
+    let mut output = Vec::new();
+    val.write_be(&mut Cursor::new(&mut output)).unwrap();
+
+    assert_eq!(output, b"\xFF\xFE\x01");
 }