use bitcoin::hashes::sha256d::Hash as Sha256dHash;
use bitcoin::hash_types::{Txid, BlockHash};
use core::marker::Sized;
+use core::time::Duration;
use ln::msgs::DecodeError;
use ln::{PaymentPreimage, PaymentHash, PaymentSecret};
/// serialization buffer size
pub const MAX_BUF_SIZE: usize = 64 * 1024;
-/// A trait that is similar to std::io::Write but has one extra function which can be used to size
-/// buffers being written into.
-/// An impl is provided for any type that also impls std::io::Write which simply ignores size
-/// hints.
+/// A simplified version of std::io::Write that exists largely for backwards compatibility.
+/// An impl is provided for any type that also impls std::io::Write.
///
/// (C-not exported) as we only export serialization to/from byte arrays instead
pub trait Writer {
/// Writes the given buf out. See std::io::Write::write_all for more
fn write_all(&mut self, buf: &[u8]) -> Result<(), io::Error>;
- /// Hints that data of the given size is about the be written. This may not always be called
- /// prior to data being written and may be safely ignored.
- fn size_hint(&mut self, size: usize);
}
impl<W: Write> Writer for W {
fn write_all(&mut self, buf: &[u8]) -> Result<(), io::Error> {
<Self as io::Write>::write_all(self, buf)
}
- #[inline]
- fn size_hint(&mut self, _size: usize) { }
}
pub(crate) struct WriterWriteAdaptor<'a, W: Writer + 'a>(pub &'a mut W);
self.0.extend_from_slice(buf);
Ok(())
}
- #[inline]
- fn size_hint(&mut self, size: usize) {
- self.0.reserve_exact(size);
- }
}
/// Writer that only tracks the amount of data written - useful if you need to calculate the length
self.0 += buf.len();
Ok(())
}
- #[inline]
- fn size_hint(&mut self, _size: usize) {}
}
/// Essentially std::io::Take but a bit simpler and with a method to walk the underlying stream
impl<K, V> Readable for HashMap<K, V>
where K: Readable + Eq + Hash,
- V: Readable
+ V: MaybeReadable
{
#[inline]
fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
let len: u16 = Readable::read(r)?;
let mut ret = HashMap::with_capacity(len as usize);
for _ in 0..len {
- ret.insert(K::read(r)?, V::read(r)?);
+ let k = K::read(r)?;
+ let v_opt = V::read(r)?;
+ if let Some(v) = v_opt {
+ if ret.insert(k, v).is_some() {
+ return Err(DecodeError::InvalidValue);
+ }
+ }
+ }
+ Ok(ret)
+ }
+}
+
+// HashSet
+impl<T> Writeable for HashSet<T>
+where T: Writeable + Eq + Hash
+{
+ #[inline]
+ fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
+ (self.len() as u16).write(w)?;
+ for item in self.iter() {
+ item.write(w)?;
+ }
+ Ok(())
+ }
+}
+
+impl<T> Readable for HashSet<T>
+where T: Readable + Eq + Hash
+{
+ #[inline]
+ fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
+ let len: u16 = Readable::read(r)?;
+ let mut ret = HashSet::with_capacity(len as usize);
+ for _ in 0..len {
+ if !ret.insert(T::read(r)?) {
+ return Err(DecodeError::InvalidValue)
+ }
}
Ok(ret)
}
self.2.write(w)
}
}
+
+impl Writeable for () {
+ fn write<W: Writer>(&self, _: &mut W) -> Result<(), io::Error> {
+ Ok(())
+ }
+}
+impl Readable for () {
+ fn read<R: Read>(_r: &mut R) -> Result<Self, DecodeError> {
+ Ok(())
+ }
+}
+
+impl Writeable for String {
+ #[inline]
+ fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
+ (self.len() as u16).write(w)?;
+ w.write_all(self.as_bytes())
+ }
+}
+impl Readable for String {
+ #[inline]
+ fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
+ let v: Vec<u8> = Readable::read(r)?;
+ let ret = String::from_utf8(v).map_err(|_| DecodeError::InvalidValue)?;
+ Ok(ret)
+ }
+}
+
+impl Writeable for Duration {
+ #[inline]
+ fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
+ self.as_secs().write(w)?;
+ self.subsec_nanos().write(w)
+ }
+}
+impl Readable for Duration {
+ #[inline]
+ fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
+ let secs = Readable::read(r)?;
+ let nanos = Readable::read(r)?;
+ Ok(Duration::new(secs, nanos))
+ }
+}