Add generic serialization implementations for Boxs and 3-tuples

[rust-lightning] / lightning / src / util / ser.rs

diff --git a/lightning/src/util/ser.rs b/lightning/src/util/ser.rs
index 61cd1e60de0ae0a57691fa8b5b858c766c451523..4e69a37d20e9fcc5e0d093804136ef9f90be1747 100644 (file)
--- a/lightning/src/util/ser.rs
+++ b/lightning/src/util/ser.rs
@@ -60,13 +60,16 @@ impl<W: Write> Writer for W {
 
 pub(crate) struct WriterWriteAdaptor<'a, W: Writer + 'a>(pub &'a mut W);
 impl<'a, W: Writer + 'a> Write for WriterWriteAdaptor<'a, W> {
+       #[inline]
        fn write_all(&mut self, buf: &[u8]) -> Result<(), ::std::io::Error> {
                self.0.write_all(buf)
        }
+       #[inline]
        fn write(&mut self, buf: &[u8]) -> Result<usize, ::std::io::Error> {
                self.0.write_all(buf)?;
                Ok(buf.len())
        }
+       #[inline]
        fn flush(&mut self) -> Result<(), ::std::io::Error> {
                Ok(())
        }
@@ -74,10 +77,12 @@ impl<'a, W: Writer + 'a> Write for WriterWriteAdaptor<'a, W> {
 
 pub(crate) struct VecWriter(pub Vec<u8>);
 impl Writer for VecWriter {
+       #[inline]
        fn write_all(&mut self, buf: &[u8]) -> Result<(), ::std::io::Error> {
                self.0.extend_from_slice(buf);
                Ok(())
        }
+       #[inline]
        fn size_hint(&mut self, size: usize) {
                self.0.reserve_exact(size);
        }
@@ -108,10 +113,12 @@ impl<R: Read> FixedLengthReader<R> {
                Self { read, bytes_read: 0, total_bytes }
        }
 
+       #[inline]
        pub fn bytes_remain(&mut self) -> bool {
                self.bytes_read != self.total_bytes
        }
 
+       #[inline]
        pub fn eat_remaining(&mut self) -> Result<(), DecodeError> {
                ::std::io::copy(self, &mut ::std::io::sink()).unwrap();
                if self.bytes_read != self.total_bytes {
@@ -122,6 +129,7 @@ impl<R: Read> FixedLengthReader<R> {
        }
 }
 impl<R: Read> Read for FixedLengthReader<R> {
+       #[inline]
        fn read(&mut self, dest: &mut [u8]) -> Result<usize, ::std::io::Error> {
                if self.total_bytes == self.bytes_read {
                        Ok(0)
@@ -150,6 +158,7 @@ impl<R: Read> ReadTrackingReader<R> {
        }
 }
 impl<R: Read> Read for ReadTrackingReader<R> {
+       #[inline]
        fn read(&mut self, dest: &mut [u8]) -> Result<usize, ::std::io::Error> {
                match self.read.read(dest) {
                        Ok(0) => Ok(0),
@@ -234,31 +243,37 @@ pub trait MaybeReadable
 
 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)?)))
        }
 }
 
-const MAX_ALLOC_SIZE: u64 = 64*1024;
-
+/// 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<(), ::std::io::Error> {
-               (self.0.len() as u64).write(writer)?;
                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: Readable>(pub Vec<T>);
 impl<T: Readable> Readable for VecReadWrapper<T> {
-       fn read<R: Read>(reader: &mut R) -> Result<Self, DecodeError> {
-               let count: u64 = Readable::read(reader)?;
-               let mut values = Vec::with_capacity(cmp::min(count, MAX_ALLOC_SIZE / (core::mem::size_of::<T>() as u64)) as usize);
-               for _ in 0..count {
-                       match Readable::read(reader) {
+       #[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 Readable::read(&mut track_read) {
                                Ok(v) => { values.push(v); },
+                               // 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),
                        }
                }
@@ -683,6 +698,18 @@ impl Readable for PaymentSecret {
        }
 }
 
+impl<T: Writeable> Writeable for Box<T> {
+       fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
+               T::write(&**self, w)
+       }
+}
+
+impl<T: Readable> Readable for Box<T> {
+       fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
+               Ok(Box::new(Readable::read(r)?))
+       }
+}
+
 impl<T: Writeable> Writeable for Option<T> {
        fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
                match *self {
@@ -809,3 +836,19 @@ impl<A: Writeable, B: Writeable> Writeable for (A, B) {
                self.1.write(w)
        }
 }
+
+impl<A: Readable, B: Readable, C: Readable> Readable for (A, B, C) {
+       fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
+               let a: A = Readable::read(r)?;
+               let b: B = Readable::read(r)?;
+               let c: C = Readable::read(r)?;
+               Ok((a, b, c))
+       }
+}
+impl<A: Writeable, B: Writeable, C: Writeable> Writeable for (A, B, C) {
+       fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
+               self.0.write(w)?;
+               self.1.write(w)?;
+               self.2.write(w)
+       }
+}