Custom context information for custom reader and writer

[eirnym]

I have custom reader and writer to (de-)compress data and assert/write additional information. Compression requires passing at least u8 to specify at compression level.

I can use reader and writer attributes, but I prefer to implement DekuReader and DekuWriter interfaces.

Currently I've done following (DekuWriter is the same, but writing data in reverse)

1. Specified structure with deriving DekuRead and DekuWrite
2. Specifed additional structure containing only Vec<u8> as public interface
3. Implement DekuRead and DekuWrite with default settings

I was unable to pass an additional parameters using custom context data.

my code for structure and reader follows below, writer is quite similar, but in reverse. ZlibDecoder/ZlibEncoder are from flate2 crate for those who'd like to compile.

Notes: PublicData doesn't implement directly DekuRead and DekuWrite as Vec<u8> require context containing limit and byte order, but they come from model above (TargetModel separate code block below).

#[derive(Debug, Clone, PartialEq)]
pub struct PublicCompressedData(Vec<u8>);

#[derive(Debug, PartialEq, DekuRead, DekuWrite)]
#[deku(magic = b"MAGK")]
struct RealData {
    decompressed_size: u32,

    #[deku(read_all)]
    data: Vec<u8>,
}

impl<'a, Predicate> DekuReader<'a, (Limit<u8, Predicate>, Endian)> for PublicCompressedData {
    ///
    /// Construct `PublicData` from `reader` implementing [`no_std_io::Read`], with ctx.
    ///
    /// Context includes limit and byte endian-ess for underlying buffer
    ///
    fn from_reader_with_ctx<R: no_std_io::Read + no_std_io::Seek>(
        reader: &mut Reader<R>,
        ctx: (Limit<u8, Predicate>, Endian),
    ) -> Result<Self, DekuError>
    where
        Self: Sized,
        Predicate: FnMut(&u8) -> bool,
    {
        let buf = <Vec<u8>>::from_reader_with_ctx(reader, ctx)?;
        let real_data = RealData::from_bytes((&buf, 0))?.1;
        let mut output = vec![];
        let _ =
            match ZlibDecoder::new(BufReader::new(real_data.data.as_slice())).read_to_end(&mut output) {
                Ok(_) => (),
                Err(err) => return Err(DekuError::Io(err.kind())),
            };

        assert_eq!(real_data.decompressed_size as usize, output.len());

        Ok(PublicCompressedData { data: output })
    }
}

impl DekuWriter<Endian> for PublicCompressedData {
    ///
    /// Write PublicCompressedData.
    ///

    fn to_writer<W: no_std_io::Write + no_std_io::Seek>(
        &self,
        writer: &mut Writer<W>,
        ctx: Endian,
    ) -> Result<(), DekuError> {
        // no length prefix atm
        let mut output = vec![];

        let compressed_size = match ZlibEncoder::new(
            BufReader::new(self.data.as_slice()),
            flate2::Compression::new(6),
        )
        .read_to_end(&mut output)
        {
            Ok(compressed_size) => compressed_size,
            Err(err) => return Err(DekuError::Io(err.kind())),
        };

        RealData {
            decompressed_size: self.data.len() as u32,
            data: output
        }.to_writer(writer, ())
    }
}

field usage:

#[derive(Debug, PartialEq, DekuRead, DekuWrite)]
struct TargetModel {
	field_a: u8,
	size: u32,
    #[deku(count = "*size", endian = "little")] // I'd like to pass compression level here
    compressed  PublicCompressedData,
}

[eirnym]

Some notes:

• synchronized context types, even this contradicts Vec<T> example.
• DekuRead doesn't work if DekuReader is implemented for the same structure, so I can't apply deku attributes to PublicCompressedData.
• Limit may be any specified by structure above, read_all is an example, count is an another example.
• I've tried to add ctx specification to PublicCompressedData such #[deku(ctx = "endian: Endian, limit: Limit<u8, Predicate>, ctx: Ctx")], which is not working, as I can't pass limit directly to vector.
• I've tried to add to TargetModel field specification for context #[deku(ctx = "(Endian::Little, Limit::from(10), 1u8)")], in all combinations, but it doesn't work, as it tells, that DekuRead wants to pass Endian and Limit.

For example, passing #[deku(ctx = "(1u8, Limit::from(10), Endian::Little)")] will produce following errors for TargetModel
macro-backtrace doesn't give more information.

   | #[derive(Debug, PartialEq, DekuRead)]
   |                            ^^^^^^^^ expected `u8`, found `Endian`
   |
   = note: this error originates in the derive macro `DekuRead` (in Nightly builds, run with -Z macro-backtrace for more info)

   |
23 |     #[deku(ctx = "(1u8, Limit::from(10), Endian::Little)")]
   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Limit<u8, _>`, found `(u8, Limit<_, fn(&_) -> bool>, Endian)`
   |
   = note: expected enum `Limit<u8, _>`
             found tuple `(u8, Limit<_, for<'a> fn(&'a _) -> bool>, Endian)`

19  | #[derive(Debug, PartialEq, DekuRead)]
    |                            ^^^^^^^^
    |                            |
    |                            expected a tuple with 3 elements, found one with 2 elements
    |                            arguments to this function are incorrect
    |
    = note: expected tuple `(u8, Limit<u8, _>, Endian)`
               found tuple `(u8, Limit<u8, _>)`

cargo-expand revealed following call in TargetModel to parse PublicCompressedData field:

                    let __deku_value = <PublicCompressedData as ::deku::DekuReader<
                        '_,
                        _,
                    >>::from_reader_with_ctx(
                        __deku_reader,
                        (
                            ::deku::ctx::Endian::Little,
                            (Endian::Little, Limit::from(10), 1u8),
                        ),
                    )?;

[eirnym]

Issue #537 has been created