Make Writeable::write typed instead of Writeable

TheBlueMatt · TheBlueMatt · commit 6f27210abc65 · 2018-09-16T14:32:35.000-04:00
This lets us add some untyped default functions to the trait
diff --git a/src/ln/msgs.rs b/src/ln/msgs.rs
@@ -742,8 +742,8 @@ impl_writeable!(AnnouncementSignatures, 32+8+64*2, {
 	bitcoin_signature
 });
 
-impl<W: Writer> Writeable<W> for ChannelReestablish {
-	fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {
+impl Writeable for ChannelReestablish {
+	fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 		w.size_hint(if self.data_loss_protect.is_some() { 32+2*8+33+32 } else { 32+2*8 });
 		self.channel_id.write(w)?;
 		self.next_local_commitment_number.write(w)?;
@@ -905,8 +905,8 @@ impl_writeable_len_match!(OnionErrorPacket, {
 	data
 });
 
-impl<W: Writer> Writeable<W> for OnionPacket {
-	fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {
+impl Writeable for OnionPacket {
+	fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 		w.size_hint(1 + 33 + 20*65 + 32);
 		self.version.write(w)?;
 		match self.public_key {
@@ -943,8 +943,8 @@ impl_writeable!(UpdateAddHTLC, 32+8+8+32+4+1366, {
 	onion_routing_packet
 });
 
-impl<W: Writer> Writeable<W> for OnionRealm0HopData {
-	fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {
+impl Writeable for OnionRealm0HopData {
+	fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 		w.size_hint(32);
 		self.short_channel_id.write(w)?;
 		self.amt_to_forward.write(w)?;
@@ -968,8 +968,8 @@ impl<R: Read> Readable<R> for OnionRealm0HopData {
 	}
 }
 
-impl<W: Writer> Writeable<W> for OnionHopData {
-	fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {
+impl Writeable for OnionHopData {
+	fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 		w.size_hint(65);
 		self.realm.write(w)?;
 		self.data.write(w)?;
@@ -994,8 +994,8 @@ impl<R: Read> Readable<R> for OnionHopData {
 	}
 }
 
-impl<W: Writer> Writeable<W> for Ping {
-	fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {
+impl Writeable for Ping {
+	fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 		w.size_hint(self.byteslen as usize + 4);
 		self.ponglen.write(w)?;
 		vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
@@ -1016,8 +1016,8 @@ impl<R: Read> Readable<R> for Ping {
 	}
 }
 
-impl<W: Writer> Writeable<W> for Pong {
-	fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {
+impl Writeable for Pong {
+	fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 		w.size_hint(self.byteslen as usize + 2);
 		vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
 		Ok(())
@@ -1036,8 +1036,8 @@ impl<R: Read> Readable<R> for Pong {
 	}
 }
 
-impl<W: Writer> Writeable<W> for UnsignedChannelAnnouncement {
-	fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {
+impl Writeable for UnsignedChannelAnnouncement {
+	fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 		w.size_hint(2 + 2*32 + 4*33 + self.features.flags.len() + self.excess_data.len());
 		self.features.write(w)?;
 		self.chain_hash.write(w)?;
@@ -1087,8 +1087,8 @@ impl_writeable_len_match!(ChannelAnnouncement, {
 	contents
 });
 
-impl<W: Writer> Writeable<W> for UnsignedChannelUpdate {
-	fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {
+impl Writeable for UnsignedChannelUpdate {
+	fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 		w.size_hint(64 + self.excess_data.len());
 		self.chain_hash.write(w)?;
 		self.short_channel_id.write(w)?;
@@ -1131,8 +1131,8 @@ impl_writeable_len_match!(ChannelUpdate, {
 	contents
 });
 
-impl<W: Writer> Writeable<W> for ErrorMessage {
-	fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {
+impl Writeable for ErrorMessage {
+	fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 		w.size_hint(32 + 2 + self.data.len());
 		self.channel_id.write(w)?;
 		(self.data.len() as u16).write(w)?;
@@ -1159,8 +1159,8 @@ impl<R: Read> Readable<R> for ErrorMessage {
 	}
 }
 
-impl<W: Writer> Writeable<W> for UnsignedNodeAnnouncement {
-	fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {
+impl Writeable for UnsignedNodeAnnouncement {
+	fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 		w.size_hint(64 + 76 + self.features.flags.len() + self.addresses.len()*38 + self.excess_address_data.len() + self.excess_data.len());
 		self.features.write(w)?;
 		self.timestamp.write(w)?;
diff --git a/src/util/ser.rs b/src/util/ser.rs
@@ -36,9 +36,9 @@ impl<W: ::std::io::Write> Writer for W {
 }
 
 /// A trait that various rust-lightning types implement allowing them to be written out to a Writer
-pub trait Writeable<W: Writer> {
+pub trait Writeable {
 	/// Writes self out to the given Writer
-	fn write(&self, writer: &mut W) -> Result<(), ::std::io::Error>;
+	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error>;
 }
 
 /// A trait that various rust-lightning types implement allowing them to be read in from a Read
@@ -52,9 +52,9 @@ pub trait Readable<R>
 
 macro_rules! impl_writeable_primitive {
 	($val_type:ty, $meth_write:ident, $len: expr, $meth_read:ident) => {
-		impl<W: Writer> Writeable<W> for $val_type {
+		impl Writeable for $val_type {
 			#[inline]
-			fn write(&self, writer: &mut W) -> Result<(), ::std::io::Error> {
+			fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error> {
 				writer.write_all(&$meth_write(*self))
 			}
 		}
@@ -73,9 +73,9 @@ impl_writeable_primitive!(u64, be64_to_array, 8, slice_to_be64);
 impl_writeable_primitive!(u32, be32_to_array, 4, slice_to_be32);
 impl_writeable_primitive!(u16, be16_to_array, 2, slice_to_be16);
 
-impl<W: Writer> Writeable<W> for u8 {
+impl Writeable for u8 {
 	#[inline]
-	fn write(&self, writer: &mut W) -> Result<(), ::std::io::Error> {
+	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error> {
 		writer.write_all(&[*self])
 	}
 }
@@ -88,9 +88,9 @@ impl<R: Read> Readable<R> for u8 {
 	}
 }
 
-impl<W: Writer> Writeable<W> for bool {
+impl Writeable for bool {
 	#[inline]
-	fn write(&self, writer: &mut W) -> Result<(), ::std::io::Error> {
+	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error> {
 		writer.write_all(&[if *self {1} else {0}])
 	}
 }
@@ -109,10 +109,10 @@ impl<R: Read> Readable<R> for bool {
 // u8 arrays
 macro_rules! impl_array {
 	( $size:expr ) => (
-		impl<W: Writer> Writeable<W> for [u8; $size]
+		impl Writeable for [u8; $size]
 		{
 			#[inline]
-			fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {
+			fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 				w.write_all(self)
 			}
 		}
@@ -136,13 +136,12 @@ impl_array!(64); // for Signature
 impl_array!(1300); // for OnionPacket.hop_data
 
 // HashMap
-impl<W, K, V> Writeable<W> for HashMap<K, V>
-	where W: Writer,
-	      K: Writeable<W> + Eq + Hash,
-	      V: Writeable<W>
+impl<K, V> Writeable for HashMap<K, V>
+	where K: Writeable + Eq + Hash,
+	      V: Writeable
 {
 	#[inline]
-	fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {
+	fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 	(self.len() as u16).write(w)?;
 		for (key, value) in self.iter() {
 			key.write(w)?;
@@ -169,9 +168,9 @@ impl<R, K, V> Readable<R> for HashMap<K, V>
 }
 
 // Vectors
-impl<W: Writer> Writeable<W> for Vec<u8> {
+impl Writeable for Vec<u8> {
 	#[inline]
-	fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {
+	fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 		(self.len() as u16).write(w)?;
 		w.write_all(&self)
 	}
@@ -187,9 +186,9 @@ impl<R: Read> Readable<R> for Vec<u8> {
 		Ok(ret)
 	}
 }
-impl<W: Writer> Writeable<W> for Vec<Signature> {
+impl Writeable for Vec<Signature> {
 	#[inline]
-	fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {
+	fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 		(self.len() as u16).write(w)?;
 		for e in self.iter() {
 			e.write(w)?;
@@ -214,8 +213,8 @@ impl<R: Read> Readable<R> for Vec<Signature> {
 	}
 }
 
-impl<W: Writer> Writeable<W> for Script {
-	fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {
+impl Writeable for Script {
+	fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 		(self.len() as u16).write(w)?;
 		w.write_all(self.as_bytes())
 	}
@@ -230,8 +229,8 @@ impl<R: Read> Readable<R> for Script {
 	}
 }
 
-impl<W: Writer> Writeable<W> for Option<Script> {
-	fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {
+impl Writeable for Option<Script> {
+	fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 		if let &Some(ref script) = self {
 			script.write(w)?;
 		}
@@ -253,8 +252,8 @@ impl<R: Read> Readable<R> for Option<Script> {
 	}
 }
 
-impl<W: Writer> Writeable<W> for PublicKey {
-	fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {
+impl Writeable for PublicKey {
+	fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 		self.serialize().write(w)
 	}
 }
@@ -269,8 +268,8 @@ impl<R: Read> Readable<R> for PublicKey {
 	}
 }
 
-impl<W: Writer> Writeable<W> for Sha256dHash {
-	fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {
+impl Writeable for Sha256dHash {
+	fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 		self.as_bytes().write(w)
 	}
 }
@@ -282,8 +281,8 @@ impl<R: Read> Readable<R> for Sha256dHash {
 	}
 }
 
-impl<W: Writer> Writeable<W> for Signature {
-	fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {
+impl Writeable for Signature {
+	fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 		self.serialize_compact(&Secp256k1::without_caps()).write(w)
 	}
 }
diff --git a/src/util/ser_macros.rs b/src/util/ser_macros.rs
@@ -1,7 +1,7 @@
 macro_rules! impl_writeable {
 	($st:ident, $len: expr, {$($field:ident),*}) => {
-		impl<W: Writer> Writeable<W> for $st {
-			fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {
+		impl Writeable for $st {
+			fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 				w.size_hint($len);
 				$( self.$field.write(w)?; )*
 				Ok(())
@@ -19,8 +19,8 @@ macro_rules! impl_writeable {
 }
 macro_rules! impl_writeable_len_match {
 	($st:ident, {$({$m: pat, $l: expr}),*}, {$($field:ident),*}) => {
-		impl<W: Writer> Writeable<W> for $st {
-			fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {
+		impl Writeable for $st {
+			fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 				w.size_hint(match *self {
 					$($m => $l,)*
 				});

Original file line number	Diff line number	Diff line change
`@@ -36,9 +36,9 @@ impl<W: ::std::io::Write> Writer for W {`
`36`	`36`	`}`
`37`	`37`
`38`	`38`	`/// A trait that various rust-lightning types implement allowing them to be written out to a Writer`
`39`		`-pub trait Writeable<W: Writer> {`
	`39`	`+pub trait Writeable {`
`40`	`40`	`/// Writes self out to the given Writer`
`41`		`- fn write(&self, writer: &mut W) -> Result<(), ::std::io::Error>;`
	`41`	`+ fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error>;`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`/// A trait that various rust-lightning types implement allowing them to be read in from a Read`
`@@ -52,9 +52,9 @@ pub trait Readable<R>`
`52`	`52`
`53`	`53`	`macro_rules! impl_writeable_primitive {`
`54`	`54`	`($val_type:ty, $meth_write:ident, $len: expr, $meth_read:ident) => {`
`55`		`- impl<W: Writer> Writeable<W> for $val_type {`
	`55`	`+ impl Writeable for $val_type {`
`56`	`56`	`#[inline]`
`57`		`- fn write(&self, writer: &mut W) -> Result<(), ::std::io::Error> {`
	`57`	`+ fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error> {`
`58`	`58`	`writer.write_all(&$meth_write(*self))`
`59`	`59`	`}`
`60`	`60`	`}`
`@@ -73,9 +73,9 @@ impl_writeable_primitive!(u64, be64_to_array, 8, slice_to_be64);`
`73`	`73`	`impl_writeable_primitive!(u32, be32_to_array, 4, slice_to_be32);`
`74`	`74`	`impl_writeable_primitive!(u16, be16_to_array, 2, slice_to_be16);`
`75`	`75`
`76`		`-impl<W: Writer> Writeable<W> for u8 {`
	`76`	`+impl Writeable for u8 {`
`77`	`77`	`#[inline]`
`78`		`- fn write(&self, writer: &mut W) -> Result<(), ::std::io::Error> {`
	`78`	`+ fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error> {`
`79`	`79`	`writer.write_all(&[*self])`
`80`	`80`	`}`
`81`	`81`	`}`
`@@ -88,9 +88,9 @@ impl<R: Read> Readable<R> for u8 {`
`88`	`88`	`}`
`89`	`89`	`}`
`90`	`90`
`91`		`-impl<W: Writer> Writeable<W> for bool {`
	`91`	`+impl Writeable for bool {`
`92`	`92`	`#[inline]`
`93`		`- fn write(&self, writer: &mut W) -> Result<(), ::std::io::Error> {`
	`93`	`+ fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error> {`
`94`	`94`	`writer.write_all(&[if *self {1} else {0}])`
`95`	`95`	`}`
`96`	`96`	`}`
`@@ -109,10 +109,10 @@ impl<R: Read> Readable<R> for bool {`
`109`	`109`	`// u8 arrays`
`110`	`110`	`macro_rules! impl_array {`
`111`	`111`	`( $size:expr ) => (`
`112`		`- impl<W: Writer> Writeable<W> for [u8; $size]`
	`112`	`+ impl Writeable for [u8; $size]`
`113`	`113`	`{`
`114`	`114`	`#[inline]`
`115`		`- fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {`
	`115`	`+ fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {`
`116`	`116`	`w.write_all(self)`
`117`	`117`	`}`
`118`	`118`	`}`
`@@ -136,13 +136,12 @@ impl_array!(64); // for Signature`
`136`	`136`	`impl_array!(1300); // for OnionPacket.hop_data`
`137`	`137`
`138`	`138`	`// HashMap`
`139`		`-impl<W, K, V> Writeable<W> for HashMap<K, V>`
`140`		`- where W: Writer,`
`141`		`- K: Writeable<W> + Eq + Hash,`
`142`		`- V: Writeable<W>`
	`139`	`+impl<K, V> Writeable for HashMap<K, V>`
	`140`	`+ where K: Writeable + Eq + Hash,`
	`141`	`+ V: Writeable`
`143`	`142`	`{`
`144`	`143`	`#[inline]`
`145`		`- fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {`
	`144`	`+ fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {`
`146`	`145`	`(self.len() as u16).write(w)?;`
`147`	`146`	`for (key, value) in self.iter() {`
`148`	`147`	`key.write(w)?;`
`@@ -169,9 +168,9 @@ impl<R, K, V> Readable<R> for HashMap<K, V>`
`169`	`168`	`}`
`170`	`169`
`171`	`170`	`// Vectors`
`172`		`-impl<W: Writer> Writeable<W> for Vec<u8> {`
	`171`	`+impl Writeable for Vec<u8> {`
`173`	`172`	`#[inline]`
`174`		`- fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {`
	`173`	`+ fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {`
`175`	`174`	`(self.len() as u16).write(w)?;`
`176`	`175`	`w.write_all(&self)`
`177`	`176`	`}`
`@@ -187,9 +186,9 @@ impl<R: Read> Readable<R> for Vec<u8> {`
`187`	`186`	`Ok(ret)`
`188`	`187`	`}`
`189`	`188`	`}`
`190`		`-impl<W: Writer> Writeable<W> for Vec<Signature> {`
	`189`	`+impl Writeable for Vec<Signature> {`
`191`	`190`	`#[inline]`
`192`		`- fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {`
	`191`	`+ fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {`
`193`	`192`	`(self.len() as u16).write(w)?;`
`194`	`193`	`for e in self.iter() {`
`195`	`194`	`e.write(w)?;`
`@@ -214,8 +213,8 @@ impl<R: Read> Readable<R> for Vec<Signature> {`
`214`	`213`	`}`
`215`	`214`	`}`
`216`	`215`
`217`		`-impl<W: Writer> Writeable<W> for Script {`
`218`		`- fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {`
	`216`	`+impl Writeable for Script {`
	`217`	`+ fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {`
`219`	`218`	`(self.len() as u16).write(w)?;`
`220`	`219`	`w.write_all(self.as_bytes())`
`221`	`220`	`}`
`@@ -230,8 +229,8 @@ impl<R: Read> Readable<R> for Script {`
`230`	`229`	`}`
`231`	`230`	`}`
`232`	`231`
`233`		`-impl<W: Writer> Writeable<W> for Option<Script> {`
`234`		`- fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {`
	`232`	`+impl Writeable for Option<Script> {`
	`233`	`+ fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {`
`235`	`234`	`if let &Some(ref script) = self {`
`236`	`235`	`script.write(w)?;`
`237`	`236`	`}`
`@@ -253,8 +252,8 @@ impl<R: Read> Readable<R> for Option<Script> {`
`253`	`252`	`}`
`254`	`253`	`}`
`255`	`254`
`256`		`-impl<W: Writer> Writeable<W> for PublicKey {`
`257`		`- fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {`
	`255`	`+impl Writeable for PublicKey {`
	`256`	`+ fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {`
`258`	`257`	`self.serialize().write(w)`
`259`	`258`	`}`
`260`	`259`	`}`
`@@ -269,8 +268,8 @@ impl<R: Read> Readable<R> for PublicKey {`
`269`	`268`	`}`
`270`	`269`	`}`
`271`	`270`
`272`		`-impl<W: Writer> Writeable<W> for Sha256dHash {`
`273`		`- fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {`
	`271`	`+impl Writeable for Sha256dHash {`
	`272`	`+ fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {`
`274`	`273`	`self.as_bytes().write(w)`
`275`	`274`	`}`
`276`	`275`	`}`
`@@ -282,8 +281,8 @@ impl<R: Read> Readable<R> for Sha256dHash {`
`282`	`281`	`}`
`283`	`282`	`}`
`284`	`283`
`285`		`-impl<W: Writer> Writeable<W> for Signature {`
`286`		`- fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {`
	`284`	`+impl Writeable for Signature {`
	`285`	`+ fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {`
`287`	`286`	`self.serialize_compact(&Secp256k1::without_caps()).write(w)`
`288`	`287`	`}`
`289`	`288`	`}`