Unable to decode a message generated with encode

[acolombier]

Hi,

I am trying to write down message to buffer, so I can read them back later.

Here is my minimal reproducing case

#[derive(Clone, PartialEq, Message)]
pub struct Packet {
    #[prost(bytes = "vec", tag = "1")]
    pub data: Vec<u8>,
}
#[derive(Clone, PartialEq, Message)]
pub struct Stream {
    #[prost(float, repeated, tag = "1")]
    pub samples: Vec<f32>,
}

#[derive(Clone, PartialEq, Message)]
pub struct Chunk {
    #[prost(message, repeated, tag = "1")]
    pub packets: Vec<Packet>,
    #[prost(message, repeated, tag = "2")]
    pub streams: Vec<Stream>,
    #[prost(uint64, tag = "3")]
    pub samples_count: u64,
}

#[cfg(test)]
mod tests {
    #[test]
    fn test_proto() {
        let mut buf = vec![0u8; 16];
        let c = Chunk {
            samples_count: 123,
            ..Default::default()
        };
        c.encode(&mut buf).unwrap();
        println!("buf: {} {:?}", c.encoded_len(), buf);
        let reader = buf.as_slice();
        let c2 = Chunk::decode(reader).unwrap();
        assert_eq!(c, c2);
    }
}

Have I misunderstood how I can use derive? Or am I missing something with the encoder setup?

Thanks for your help!

[acolombier]

Looks like I had both misunderstood prost and bytes auto trait for Vec. Here is the working example:

#[cfg(test)]
mod tests {
    #[test]
    fn test_proto() {
        let mut buf = Vec::with_capacity(10); // Vec's len will be used as offset so must be 0.
        let c = Chunk {
            samples_count: 123,
            ..Default::default()
        };
        c.encode_length_delimited(&mut buf).unwrap();
        let mut reader = buf.as_slice();
        let c2 = Chunk::decode_length_delimited(reader).unwrap();
        assert_eq!(c, c2);
    }
}

[acolombier]

Actually, it doesn't seem to be working quite as expected, when putting multiple messages. Is this an expected limitation? Should I handle the length limitation explicitly such as:

#[cfg(test)]
mod tests {
    #[test]
    fn test_proto() {
        let mut buf = Vec::with_capacity(10);
        let mut c = Chunk {
            samples_count: 123,
            ..Default::default()
        };
        c.encode_length_delimited(&mut buf).unwrap();
        buf.put_f64(123.456);
        println!("buf: {} {:?} {:?}", c.encoded_len(), buf, c.encode_to_vec());
        let mut reader = &buf[..];
        let len = prost::encoding::varint::decode_varint(&mut reader).unwrap() as usize;
        let c2 = Chunk::decode(&reader[..len]).unwrap();
        reader.advance(len);
        let b = reader.get_f64();
        assert_eq!(c, c2);
        assert_eq!(b, 123.456);
    }
}

It does feel strange that I would have to "advance" the reader explicitly, is this how this is intended to be used?