Make Readable::read a templated on the stream, not Readable itself

[rust-lightning] / lightning / src / ln / channelmanager.rs

diff --git a/lightning/src/ln/channelmanager.rs b/lightning/src/ln/channelmanager.rs
index 476d5be8961b21d8c42517c85334e659d7dd7d38..5f7e903fd201c6da81c0eadf20dd61d6f98e2dd6 100644 (file)
--- a/lightning/src/ln/channelmanager.rs
+++ b/lightning/src/ln/channelmanager.rs
@@ -3062,8 +3062,8 @@ impl Writeable for PendingHTLCInfo {
        }
 }
 
-impl<R: ::std::io::Read> Readable<R> for PendingHTLCInfo {
-       fn read(reader: &mut R) -> Result<PendingHTLCInfo, DecodeError> {
+impl Readable for PendingHTLCInfo {
+       fn read<R: ::std::io::Read>(reader: &mut R) -> Result<PendingHTLCInfo, DecodeError> {
                Ok(PendingHTLCInfo {
                        onion_packet: Readable::read(reader)?,
                        incoming_shared_secret: Readable::read(reader)?,
@@ -3091,9 +3091,9 @@ impl Writeable for HTLCFailureMsg {
        }
 }
 
-impl<R: ::std::io::Read> Readable<R> for HTLCFailureMsg {
-       fn read(reader: &mut R) -> Result<HTLCFailureMsg, DecodeError> {
-               match <u8 as Readable<R>>::read(reader)? {
+impl Readable for HTLCFailureMsg {
+       fn read<R: ::std::io::Read>(reader: &mut R) -> Result<HTLCFailureMsg, DecodeError> {
+               match <u8 as Readable>::read(reader)? {
                        0 => Ok(HTLCFailureMsg::Relay(Readable::read(reader)?)),
                        1 => Ok(HTLCFailureMsg::Malformed(Readable::read(reader)?)),
                        _ => Err(DecodeError::InvalidValue),
@@ -3117,9 +3117,9 @@ impl Writeable for PendingHTLCStatus {
        }
 }
 
-impl<R: ::std::io::Read> Readable<R> for PendingHTLCStatus {
-       fn read(reader: &mut R) -> Result<PendingHTLCStatus, DecodeError> {
-               match <u8 as Readable<R>>::read(reader)? {
+impl Readable for PendingHTLCStatus {
+       fn read<R: ::std::io::Read>(reader: &mut R) -> Result<PendingHTLCStatus, DecodeError> {
+               match <u8 as Readable>::read(reader)? {
                        0 => Ok(PendingHTLCStatus::Forward(Readable::read(reader)?)),
                        1 => Ok(PendingHTLCStatus::Fail(Readable::read(reader)?)),
                        _ => Err(DecodeError::InvalidValue),
@@ -3151,9 +3151,9 @@ impl Writeable for HTLCSource {
        }
 }
 
-impl<R: ::std::io::Read> Readable<R> for HTLCSource {
-       fn read(reader: &mut R) -> Result<HTLCSource, DecodeError> {
-               match <u8 as Readable<R>>::read(reader)? {
+impl Readable for HTLCSource {
+       fn read<R: ::std::io::Read>(reader: &mut R) -> Result<HTLCSource, DecodeError> {
+               match <u8 as Readable>::read(reader)? {
                        0 => Ok(HTLCSource::PreviousHopData(Readable::read(reader)?)),
                        1 => Ok(HTLCSource::OutboundRoute {
                                route: Readable::read(reader)?,
@@ -3182,9 +3182,9 @@ impl Writeable for HTLCFailReason {
        }
 }
 
-impl<R: ::std::io::Read> Readable<R> for HTLCFailReason {
-       fn read(reader: &mut R) -> Result<HTLCFailReason, DecodeError> {
-               match <u8 as Readable<R>>::read(reader)? {
+impl Readable for HTLCFailReason {
+       fn read<R: ::std::io::Read>(reader: &mut R) -> Result<HTLCFailReason, DecodeError> {
+               match <u8 as Readable>::read(reader)? {
                        0 => Ok(HTLCFailReason::LightningError { err: Readable::read(reader)? }),
                        1 => Ok(HTLCFailReason::Reason {
                                failure_code: Readable::read(reader)?,
@@ -3214,9 +3214,9 @@ impl Writeable for HTLCForwardInfo {
        }
 }
 
-impl<R: ::std::io::Read> Readable<R> for HTLCForwardInfo {
-       fn read(reader: &mut R) -> Result<HTLCForwardInfo, DecodeError> {
-               match <u8 as Readable<R>>::read(reader)? {
+impl Readable for HTLCForwardInfo {
+       fn read<R: ::std::io::Read>(reader: &mut R) -> Result<HTLCForwardInfo, DecodeError> {
+               match <u8 as Readable>::read(reader)? {
                        0 => Ok(HTLCForwardInfo::AddHTLC {
                                prev_short_channel_id: Readable::read(reader)?,
                                prev_htlc_id: Readable::read(reader)?,
@@ -3355,27 +3355,27 @@ pub struct ChannelManagerReadArgs<'a, ChanSigner: 'a + ChannelKeys, M: Deref, T:
 
 // Implement ReadableArgs for an Arc'd ChannelManager to make it a bit easier to work with the
 // SipmleArcChannelManager type:
-impl<'a, R : ::std::io::Read, ChanSigner: ChannelKeys + Readable<R>, M: Deref, T: Deref, K: Deref, F: Deref>
-       ReadableArgs<R, ChannelManagerReadArgs<'a, ChanSigner, M, T, K, F>> for (Sha256dHash, Arc<ChannelManager<ChanSigner, M, T, K, F>>)
+impl<'a, ChanSigner: ChannelKeys + Readable, M: Deref, T: Deref, K: Deref, F: Deref>
+       ReadableArgs<ChannelManagerReadArgs<'a, ChanSigner, M, T, K, F>> for (Sha256dHash, Arc<ChannelManager<ChanSigner, M, T, K, F>>)
        where M::Target: ManyChannelMonitor<ChanSigner>,
         T::Target: BroadcasterInterface,
         K::Target: KeysInterface<ChanKeySigner = ChanSigner>,
         F::Target: FeeEstimator,
 {
-       fn read(reader: &mut R, args: ChannelManagerReadArgs<'a, ChanSigner, M, T, K, F>) -> Result<Self, DecodeError> {
+       fn read<R: ::std::io::Read>(reader: &mut R, args: ChannelManagerReadArgs<'a, ChanSigner, M, T, K, F>) -> Result<Self, DecodeError> {
                let (blockhash, chan_manager) = <(Sha256dHash, ChannelManager<ChanSigner, M, T, K, F>)>::read(reader, args)?;
                Ok((blockhash, Arc::new(chan_manager)))
        }
 }
 
-impl<'a, R : ::std::io::Read, ChanSigner: ChannelKeys + Readable<R>, M: Deref, T: Deref, K: Deref, F: Deref>
-       ReadableArgs<R, ChannelManagerReadArgs<'a, ChanSigner, M, T, K, F>> for (Sha256dHash, ChannelManager<ChanSigner, M, T, K, F>)
+impl<'a, ChanSigner: ChannelKeys + Readable, M: Deref, T: Deref, K: Deref, F: Deref>
+       ReadableArgs<ChannelManagerReadArgs<'a, ChanSigner, M, T, K, F>> for (Sha256dHash, ChannelManager<ChanSigner, M, T, K, F>)
        where M::Target: ManyChannelMonitor<ChanSigner>,
         T::Target: BroadcasterInterface,
         K::Target: KeysInterface<ChanKeySigner = ChanSigner>,
         F::Target: FeeEstimator,
 {
-       fn read(reader: &mut R, args: ChannelManagerReadArgs<'a, ChanSigner, M, T, K, F>) -> Result<Self, DecodeError> {
+       fn read<R: ::std::io::Read>(reader: &mut R, args: ChannelManagerReadArgs<'a, ChanSigner, M, T, K, F>) -> Result<Self, DecodeError> {
                let _ver: u8 = Readable::read(reader)?;
                let min_ver: u8 = Readable::read(reader)?;
                if min_ver > SERIALIZATION_VERSION {