Forward consensus_decode to consensus_decode_from_finite_reader

dpc · dpc · commit a24a3b01941b · 2022-06-23T15:55:21.000-07:00
diff --git a/src/blockdata/script.rs b/src/blockdata/script.rs
@@ -23,11 +23,9 @@
 //! This module provides the structures and functions needed to support scripts.
 //!
 
-use crate::consensus::encode::MAX_VEC_SIZE;
 use crate::prelude::*;
 
 use crate::io;
-use io::Read as _;
 use core::{fmt, default::Default};
 use core::ops::Index;
 
@@ -1103,11 +1101,6 @@ impl Decodable for Script {
     fn consensus_decode_from_finite_reader<R: io::Read>(r: &mut R) -> Result<Self, encode::Error> {
         Ok(Script(Decodable::consensus_decode_from_finite_reader(r)?))
     }
-
-    #[inline]
-    fn consensus_decode<R: io::Read>(r: &mut R) -> Result<Self, encode::Error> {
-        Self::consensus_decode_from_finite_reader(r.take(MAX_VEC_SIZE as u64).by_ref())
-    }
 }
 
 #[cfg(test)]
diff --git a/src/blockdata/transaction.rs b/src/blockdata/transaction.rs
@@ -26,7 +26,6 @@
 use crate::prelude::*;
 
 use crate::io;
-use io::Read as _;
 use core::{fmt, str, default::Default};
 
 use crate::hashes::{self, Hash, sha256d};
@@ -38,7 +37,6 @@ use crate::blockdata::constants::WITNESS_SCALE_FACTOR;
 use crate::blockdata::script::Script;
 use crate::blockdata::witness::Witness;
 use crate::consensus::{encode, Decodable, Encodable};
-use crate::consensus::encode::MAX_VEC_SIZE;
 use crate::hash_types::{Sighash, Txid, Wtxid};
 use crate::VarInt;
 
@@ -687,11 +685,6 @@ impl Decodable for TxIn {
             witness: Witness::default(),
         })
     }
-
-    #[inline]
-    fn consensus_decode<R: io::Read>(r: &mut R) -> Result<Self, encode::Error> {
-        Self::consensus_decode_from_finite_reader(r.take(MAX_VEC_SIZE as u64).by_ref())
-    }
 }
 
 impl Encodable for Transaction {
@@ -763,10 +756,6 @@ impl Decodable for Transaction {
             })
         }
     }
-
-    fn consensus_decode<R: io::Read>(r: &mut R) -> Result<Self, encode::Error> {
-        Self::consensus_decode_from_finite_reader(&mut r.take(MAX_VEC_SIZE as u64))
-    }
 }
 
 /// This type is consensus valid but an input including it would prevent the transaction from
diff --git a/src/consensus/encode.rs b/src/consensus/encode.rs
@@ -353,6 +353,7 @@ pub trait Decodable: Sized {
     ///   should also implement it applying same rules, and in addition make sure to call
     ///   `consensus_decode_from_finite_reader` on all members, to avoid creating redundant
     ///   `Take` wrappers. Failure to do so might result only in a tiny performance hit.
+    #[inline]
     fn consensus_decode_from_finite_reader<R: io::Read>(reader: &mut R) -> Result<Self, Error> {
         // This method is always strictly less general than, `consensus_decode`,
         // so it's safe and make sense to default to just calling it.
@@ -361,8 +362,18 @@ pub trait Decodable: Sized {
         Self::consensus_decode(reader)
     }
 
-    /// Decode an object with a well-defined format
-    fn consensus_decode<R: io::Read>(reader: &mut R) -> Result<Self, Error>;
+    /// Decode an object with a well-defined format.
+    ///
+    /// This is the method that should be implemented for a typical, fixed sized type
+    /// implementing this trait. Default implementation is wrapping the reader
+    /// in [`crate::io::Take`] to limit the input size to [`MAX_VEC_SIZE`], and forwards the call to
+    /// [`Self::consensus_decode_from_finite_reader`], which is convenient
+    /// for types that override [`Self::consensus_decode_from_finite_reader`]
+    /// instead.
+    #[inline]
+    fn consensus_decode<R: io::Read>(reader: &mut R) -> Result<Self, Error> {
+        Self::consensus_decode_from_finite_reader(reader.take(MAX_VEC_SIZE as u64).by_ref())
+    }
 }
 
 /// A variable-length unsigned integer
@@ -616,11 +627,6 @@ macro_rules! impl_vec {
                 }
                 Ok(ret)
             }
-
-            #[inline]
-            fn consensus_decode<R: io::Read>(d: &mut R) -> Result<Self, Error> {
-                Self::consensus_decode_from_finite_reader(&mut d.take(MAX_VEC_SIZE as u64))
-            }
         }
     }
 }
@@ -687,11 +693,6 @@ impl Decodable for Vec<u8> {
         // most real-world vec of bytes data, wouldn't be larger than 128KiB
         read_bytes_from_finite_reader(r, ReadBytesFromFiniteReaderOpts { len, chunk_size: 128 * 1024 })
     }
-
-    #[inline]
-    fn consensus_decode<R: io::Read>(r: &mut R) -> Result<Self, Error> {
-        Self::consensus_decode_from_finite_reader(&mut r.take(MAX_VEC_SIZE as u64))
-    }
 }
 
 impl Encodable for Box<[u8]> {
@@ -706,11 +707,6 @@ impl Decodable for Box<[u8]> {
     fn consensus_decode_from_finite_reader<R: io::Read>(r: &mut R) -> Result<Self, Error> {
         <Vec<u8>>::consensus_decode_from_finite_reader(r).map(From::from)
     }
-
-    #[inline]
-    fn consensus_decode<R: io::Read>(r: &mut R) -> Result<Self, Error> {
-        Self::consensus_decode_from_finite_reader(&mut r.take(MAX_VEC_SIZE as u64))
-    }
 }
 
 
@@ -748,10 +744,6 @@ impl Decodable for CheckedData {
             Ok(CheckedData(ret))
         }
     }
-
-    fn consensus_decode<R: io::Read>(d: &mut R) -> Result<Self, Error> {
-        Self::consensus_decode_from_finite_reader(&mut d.take(MAX_VEC_SIZE as u64))
-    }
 }
 
 // References
diff --git a/src/util/psbt/mod.rs b/src/util/psbt/mod.rs
@@ -23,14 +23,12 @@ use core::cmp;
 
 use crate::blockdata::script::Script;
 use crate::blockdata::transaction::{ TxOut, Transaction};
-use crate::consensus::encode::MAX_VEC_SIZE;
 use crate::consensus::{encode, Encodable, Decodable};
 pub use crate::util::sighash::Prevouts;
 
 use crate::prelude::*;
 
 use crate::io;
-use io::Read as _;
 mod error;
 pub use self::error::Error;
 
@@ -342,11 +340,6 @@ impl Decodable for PartiallySignedTransaction {
         global.outputs = outputs;
         Ok(global)
     }
-
-    #[inline]
-    fn consensus_decode<R: io::Read>(d: &mut R) -> Result<Self, encode::Error> {
-        Self::consensus_decode_from_finite_reader(d.take(MAX_VEC_SIZE as u64).by_ref())
-    }
 }
 
 #[cfg(test)]

Original file line number	Diff line number	Diff line change
`@@ -353,6 +353,7 @@ pub trait Decodable: Sized {`
`353`	`353`	`/// should also implement it applying same rules, and in addition make sure to call`
`354`	`354`	/// `consensus_decode_from_finite_reader` on all members, to avoid creating redundant
`355`	`355`	/// `Take` wrappers. Failure to do so might result only in a tiny performance hit.
	`356`	`+ #[inline]`
`356`	`357`	`fn consensus_decode_from_finite_reader<R: io::Read>(reader: &mut R) -> Result<Self, Error> {`
`357`	`358`	// This method is always strictly less general than, `consensus_decode`,
`358`	`359`	`// so it's safe and make sense to default to just calling it.`
`@@ -361,8 +362,18 @@ pub trait Decodable: Sized {`
`361`	`362`	`Self::consensus_decode(reader)`
`362`	`363`	`}`
`363`	`364`
`364`		`- /// Decode an object with a well-defined format`
`365`		`- fn consensus_decode<R: io::Read>(reader: &mut R) -> Result<Self, Error>;`
	`365`	`+ /// Decode an object with a well-defined format.`
	`366`	`+ ///`
	`367`	`+ /// This is the method that should be implemented for a typical, fixed sized type`
	`368`	`+ /// implementing this trait. Default implementation is wrapping the reader`
	`369`	+ /// in [`crate::io::Take`] to limit the input size to [`MAX_VEC_SIZE`], and forwards the call to
	`370`	+ /// [`Self::consensus_decode_from_finite_reader`], which is convenient
	`371`	+ /// for types that override [`Self::consensus_decode_from_finite_reader`]
	`372`	`+ /// instead.`
	`373`	`+ #[inline]`
	`374`	`+ fn consensus_decode<R: io::Read>(reader: &mut R) -> Result<Self, Error> {`
	`375`	`+ Self::consensus_decode_from_finite_reader(reader.take(MAX_VEC_SIZE as u64).by_ref())`
	`376`	`+ }`
`366`	`377`	`}`
`367`	`378`
`368`	`379`	`/// A variable-length unsigned integer`
`@@ -616,11 +627,6 @@ macro_rules! impl_vec {`
`616`	`627`	`}`
`617`	`628`	`Ok(ret)`
`618`	`629`	`}`
`619`		`-`
`620`		`- #[inline]`
`621`		`- fn consensus_decode<R: io::Read>(d: &mut R) -> Result<Self, Error> {`
`622`		`- Self::consensus_decode_from_finite_reader(&mut d.take(MAX_VEC_SIZE as u64))`
`623`		`- }`
`624`	`630`	`}`
`625`	`631`	`}`
`626`	`632`	`}`
`@@ -687,11 +693,6 @@ impl Decodable for Vec<u8> {`
`687`	`693`	`// most real-world vec of bytes data, wouldn't be larger than 128KiB`
`688`	`694`	`read_bytes_from_finite_reader(r, ReadBytesFromFiniteReaderOpts { len, chunk_size: 128 * 1024 })`
`689`	`695`	`}`
`690`		`-`
`691`		`- #[inline]`
`692`		`- fn consensus_decode<R: io::Read>(r: &mut R) -> Result<Self, Error> {`
`693`		`- Self::consensus_decode_from_finite_reader(&mut r.take(MAX_VEC_SIZE as u64))`
`694`		`- }`
`695`	`696`	`}`
`696`	`697`
`697`	`698`	`impl Encodable for Box<[u8]> {`
`@@ -706,11 +707,6 @@ impl Decodable for Box<[u8]> {`
`706`	`707`	`fn consensus_decode_from_finite_reader<R: io::Read>(r: &mut R) -> Result<Self, Error> {`
`707`	`708`	`<Vec<u8>>::consensus_decode_from_finite_reader(r).map(From::from)`
`708`	`709`	`}`
`709`		`-`
`710`		`- #[inline]`
`711`		`- fn consensus_decode<R: io::Read>(r: &mut R) -> Result<Self, Error> {`
`712`		`- Self::consensus_decode_from_finite_reader(&mut r.take(MAX_VEC_SIZE as u64))`
`713`		`- }`
`714`	`710`	`}`
`715`	`711`
`716`	`712`
`@@ -748,10 +744,6 @@ impl Decodable for CheckedData {`
`748`	`744`	`Ok(CheckedData(ret))`
`749`	`745`	`}`
`750`	`746`	`}`
`751`		`-`
`752`		`- fn consensus_decode<R: io::Read>(d: &mut R) -> Result<Self, Error> {`
`753`		`- Self::consensus_decode_from_finite_reader(&mut d.take(MAX_VEC_SIZE as u64))`
`754`		`- }`
`755`	`747`	`}`
`756`	`748`
`757`	`749`	`// References`