+ fn read<R: Read>(reader: &mut R, params: P) -> Result<Self, DecodeError>;
+}
+
+/// A trait that various rust-lightning types implement allowing them to (maybe) be read in from a Read
+///
+/// (C-not exported) as we only export serialization to/from byte arrays instead
+pub trait MaybeReadable
+ where Self: Sized
+{
+ /// Reads a Self in from the given Read
+ fn read<R: Read>(reader: &mut R) -> Result<Option<Self>, DecodeError>;
+}
+
+impl<T: Readable> MaybeReadable for T {
+ #[inline]
+ fn read<R: Read>(reader: &mut R) -> Result<Option<T>, DecodeError> {
+ Ok(Some(Readable::read(reader)?))
+ }
+}
+
+pub(crate) struct OptionDeserWrapper<T: Readable>(pub Option<T>);
+impl<T: Readable> Readable for OptionDeserWrapper<T> {
+ #[inline]
+ fn read<R: Read>(reader: &mut R) -> Result<Self, DecodeError> {
+ Ok(Self(Some(Readable::read(reader)?)))
+ }
+}
+
+/// Wrapper to write each element of a Vec with no length prefix
+pub(crate) struct VecWriteWrapper<'a, T: Writeable>(pub &'a Vec<T>);
+impl<'a, T: Writeable> Writeable for VecWriteWrapper<'a, T> {
+ #[inline]
+ fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
+ for ref v in self.0.iter() {
+ v.write(writer)?;
+ }
+ Ok(())
+ }
+}
+
+/// Wrapper to read elements from a given stream until it reaches the end of the stream.
+pub(crate) struct VecReadWrapper<T>(pub Vec<T>);
+impl<T: MaybeReadable> Readable for VecReadWrapper<T> {
+ #[inline]
+ fn read<R: Read>(mut reader: &mut R) -> Result<Self, DecodeError> {
+ let mut values = Vec::new();
+ loop {
+ let mut track_read = ReadTrackingReader::new(&mut reader);
+ match MaybeReadable::read(&mut track_read) {
+ Ok(Some(v)) => { values.push(v); },
+ Ok(None) => { },
+ // If we failed to read any bytes at all, we reached the end of our TLV
+ // stream and have simply exhausted all entries.
+ Err(ref e) if e == &DecodeError::ShortRead && !track_read.have_read => break,
+ Err(e) => return Err(e),
+ }
+ }
+ Ok(Self(values))
+ }