From f18157e7741620884049b149f3f5cac0f08c43a2 Mon Sep 17 00:00:00 2001 From: Andrew Poelstra Date: Thu, 18 Feb 2016 19:25:40 +0000 Subject: [PATCH] Minor code changes for new rustc/clippy. No effects. Update minor version number --- Cargo.toml | 2 +- src/blockdata/blockchain.rs | 6 +- src/blockdata/constants.rs | 2 +- src/blockdata/script.rs | 206 +++++++++++++++--------------------- src/internal_macros.rs | 4 +- src/network/encodable.rs | 2 +- src/util/contracthash.rs | 6 +- src/util/hash.rs | 8 +- src/util/patricia_tree.rs | 4 +- 9 files changed, 102 insertions(+), 138 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index a003106c..20774bcc 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,7 +1,7 @@ [package] name = "bitcoin" -version = "0.5.3" +version = "0.5.4" authors = ["Andrew Poelstra "] license = "CC0-1.0" homepage = "https://github.com/apoelstra/rust-bitcoin/" diff --git a/src/blockdata/blockchain.rs b/src/blockdata/blockchain.rs index 30552bb3..61595df9 100644 --- a/src/blockdata/blockchain.rs +++ b/src/blockdata/blockchain.rs @@ -547,7 +547,7 @@ impl Blockchain { } /// An iterator over all blocks in the chain starting from `start_hash` - pub fn iter<'a>(&'a self, start_hash: Sha256dHash) -> BlockIter<'a> { + pub fn iter(&self, start_hash: Sha256dHash) -> BlockIter { let start = match self.tree.lookup(&start_hash.into_le(), 256) { Some(boxptr) => &**boxptr as NodePtr, None => ptr::null() @@ -559,7 +559,7 @@ impl Blockchain { } /// An iterator over all blocks in reverse order to the genesis, starting with `start_hash` - pub fn rev_iter<'a>(&'a self, start_hash: Sha256dHash) -> RevBlockIter<'a> { + pub fn rev_iter(&self, start_hash: Sha256dHash) -> RevBlockIter { let start = match self.tree.lookup(&start_hash.into_le(), 256) { Some(boxptr) => &**boxptr as NodePtr, None => ptr::null() @@ -571,7 +571,7 @@ impl Blockchain { } /// An iterator over all blocks -not- in the best chain, in reverse order, starting from `start_hash` - pub fn rev_stale_iter<'a>(&'a self, start_hash: Sha256dHash) -> RevStaleBlockIter<'a> { + pub fn rev_stale_iter(&self, start_hash: Sha256dHash) -> RevStaleBlockIter { let start = match self.tree.lookup(&start_hash.into_le(), 256) { Some(boxptr) => { // If we are already on the main chain, we have a dead iterator diff --git a/src/blockdata/constants.rs b/src/blockdata/constants.rs index ab5196b6..b97a4d48 100644 --- a/src/blockdata/constants.rs +++ b/src/blockdata/constants.rs @@ -67,7 +67,7 @@ fn bitcoin_genesis_tx() -> Transaction { // Inputs let in_script = script::Builder::new().push_scriptint(486604799) .push_scriptint(4) - .push_slice("The Times 03/Jan/2009 Chancellor on brink of second bailout for banks".as_bytes()) + .push_slice(b"The Times 03/Jan/2009 Chancellor on brink of second bailout for banks") .into_script(); ret.input.push(TxIn { prev_hash: Default::default(), diff --git a/src/blockdata/script.rs b/src/blockdata/script.rs index 1ec9ed05..3456be91 100644 --- a/src/blockdata/script.rs +++ b/src/blockdata/script.rs @@ -24,7 +24,6 @@ //! This module provides the structures and functions needed to support scripts. //! -use std::hash; use std::default::Default; use std::{error, fmt, ops}; use serialize::hex::ToHex; @@ -44,7 +43,7 @@ use network::serialize::{SimpleDecoder, SimpleEncoder, serialize}; use util::hash::Sha256dHash; use util::misc::script_find_and_remove; -#[derive(PartialEq, Eq)] +#[derive(Clone, PartialEq, Eq, Hash)] /// A Bitcoin script pub struct Script(Box<[u8]>); @@ -126,12 +125,6 @@ impl fmt::Display for Script { } } -impl Clone for Script { - fn clone(&self) -> Script { - Script(self.0.to_vec().into_boxed_slice()) - } -} - impl fmt::LowerHex for Script { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { for &ch in self.0.iter() { @@ -155,24 +148,6 @@ impl fmt::UpperHex for Script { pub struct Builder(Vec); display_from_debug!(Builder); -impl hash::Hash for Script { - #[inline] - fn hash(&self, state: &mut H) - where H: hash::Hasher - { - (&self.0[..]).hash(state); - } - - #[inline] - fn hash_slice(data: &[Script], state: &mut H) - where H: hash::Hasher - { - for s in data.iter() { - (&s.0[..]).hash(state); - } - } -} - /// Ways that a script might fail. Not everything is split up as /// much as it could be; patches welcome if more detailed errors /// would help you. @@ -1083,12 +1058,9 @@ impl AbstractStackElem { try!(self.set_len_lo(val.len())); try!(self.set_len_hi(val.len())); try!(self.set_bool_value(read_scriptbool(val))); - match read_scriptint(val) { - Ok(n) => { - try!(self.set_num_lo(n)); - try!(self.set_num_hi(n)); - } - Err(_) => {} + if let Ok(n) = read_scriptint(val) { + try!(self.set_num_lo(n)); + try!(self.set_num_hi(n)); } try!(self.set_bool_value(read_scriptbool(val))); self.raw = Some(val.to_vec()); @@ -1645,8 +1617,8 @@ pub fn read_uint(data: &[u8], size: usize) -> Result { Err(Error::EarlyEndOfScript) } else { let mut ret = 0; - for i in 0..size { - ret += (data[i] as usize) << (i * 8); + for (i, item) in data.iter().take(size).enumerate() { + ret += (*item as usize) << (i * 8); } Ok(ret) } @@ -1763,41 +1735,40 @@ fn check_signature(secp: &Secp256k1, sig_slice: &[u8], pk_slice: &[u8], script: // always come first and `drop` should always come last, to avoid // surprises. macro_rules! stack_opcode { - ($stack:ident($min:expr): $($cmd:ident $args:tt);*) => ({ - $(stack_opcode_internal!($cmd: $stack, $min, $args);)* + ($stack:ident: $($cmd:ident $args:tt);*) => ({ + // Record top + let mut top = $stack.len(); + &mut top; // shut up warnings in case top is either unread or unmutated + $(stack_opcode_internal!($cmd: $stack, top, $args);)* }); } // The actual commands available to the above macro macro_rules! stack_opcode_internal { - (require: $stack:ident, $min:expr, $r:expr) => ({ + (require: $stack:ident, $top:ident, $r:expr) => ({ $stack.require_n_elems($r); - // Record top - let top = $stack.len(); - // Check stack size - if top < $min { return Err(Error::PopEmptyStack); } + $top = $stack.len(); }); - (copy: $stack:ident, $min:expr, $c:expr) => ({ - let top = $stack.len(); - if top < $min { return Err(Error::PopEmptyStack); } - let elem = $stack[top - $c].clone(); + (copy: $stack:ident, $top:ident, $c:expr) => ({ + if $top < $c { return Err(Error::PopEmptyStack); } + let elem = $stack[$top - $c].clone(); $stack.push(elem); }); - (swap: $stack:ident, $min:expr, ($a:expr, $b:expr)) => ({ - let top = $stack.len(); - if top < $min { return Err(Error::PopEmptyStack); } - (&mut $stack[..]).swap(top - $a, top - $b); + (swap: $stack:ident, $top:ident, ($a:expr, $b:expr)) => ({ + if $top < $a || $top < $b { return Err(Error::PopEmptyStack); } + (&mut $stack[..]).swap($top - $a, $top - $b); }); - (perm: $stack:ident, $min:expr, ($first:expr, $($i:expr),*)) => ({ - let top = $stack.len(); - if top < $min { return Err(Error::PopEmptyStack); } + (perm: $stack:ident, $top:ident, ($first:expr, $($i:expr),*)) => ({ + if $top < $first { return Err(Error::PopEmptyStack); } let first = $first; - $( (&mut $stack[..]).swap(top - first, top - $i); )* + $( + if $top < $i { return Err(Error::PopEmptyStack); } + (&mut $stack[..]).swap($top - first, $top - $i); + )* }); - (drop: $stack:ident, $min:expr, $d:expr) => ({ - let top = $stack.len(); - if top < $min { return Err(Error::PopEmptyStack); } - $stack.remove(top - $d); + (drop: $stack:ident, $top:ident, $d:expr) => ({ + if $top < $d { return Err(Error::PopEmptyStack); } + $stack.remove($top - $d); }); } @@ -1936,20 +1907,17 @@ impl Script { let executing = exec_stack.iter().all(|e| *e); let byte = self.0[index]; // Write out the trace, except the stack which we don't know yet - match trace { - Some(ref mut t) => { - let opcode = opcodes::All::from(byte); - t.push(TraceIteration { - index: index, - opcode: opcode, - executed: executing, - errored: true, - op_count: op_count, - effect: opcode.classify(), - stack: vec!["".to_owned()] - }); - } - None => {} + if let Some(ref mut t) = trace { + let opcode = opcodes::All::from(byte); + t.push(TraceIteration { + index: index, + opcode: opcode, + executed: executing, + errored: true, + op_count: op_count, + effect: opcode.classify(), + stack: vec!["".to_owned()] + }); } op_count += 1; index += 1; @@ -1990,7 +1958,7 @@ impl Script { index += 4 + n; } // If-statements take effect when not executing - (false, opcodes::Class::Ordinary(opcodes::Ordinary::OP_IF)) => exec_stack.push(false), + (false, opcodes::Class::Ordinary(opcodes::Ordinary::OP_IF)) | (false, opcodes::Class::Ordinary(opcodes::Ordinary::OP_NOTIF)) => exec_stack.push(false), (false, opcodes::Class::Ordinary(opcodes::Ordinary::OP_ELSE)) => { match exec_stack.last_mut() { @@ -2047,17 +2015,17 @@ impl Script { Some(elem) => { stack.push(elem); } } } - opcodes::Ordinary::OP_2DROP => stack_opcode!(stack(2): drop 1; drop 2), - opcodes::Ordinary::OP_2DUP => stack_opcode!(stack(2): copy 2; copy 1), - opcodes::Ordinary::OP_3DUP => stack_opcode!(stack(3): copy 3; copy 2; copy 1), - opcodes::Ordinary::OP_2OVER => stack_opcode!(stack(4): copy 4; copy 3), - opcodes::Ordinary::OP_2ROT => stack_opcode!(stack(6): perm (1, 3, 5); - perm (2, 4, 6)), - opcodes::Ordinary::OP_2SWAP => stack_opcode!(stack(4): swap (2, 4); swap (1, 3)), - opcodes::Ordinary::OP_DROP => stack_opcode!(stack(1): drop 1), - opcodes::Ordinary::OP_DUP => stack_opcode!(stack(1): copy 1), - opcodes::Ordinary::OP_NIP => stack_opcode!(stack(2): drop 2), - opcodes::Ordinary::OP_OVER => stack_opcode!(stack(2): copy 2), + opcodes::Ordinary::OP_2DROP => stack_opcode!(stack: drop 1; drop 2), + opcodes::Ordinary::OP_2DUP => stack_opcode!(stack: copy 2; copy 1), + opcodes::Ordinary::OP_3DUP => stack_opcode!(stack: copy 3; copy 2; copy 1), + opcodes::Ordinary::OP_2OVER => stack_opcode!(stack: copy 4; copy 3), + opcodes::Ordinary::OP_2ROT => stack_opcode!(stack: perm (1, 3, 5); + perm (2, 4, 6)), + opcodes::Ordinary::OP_2SWAP => stack_opcode!(stack: swap (2, 4); swap (1, 3)), + opcodes::Ordinary::OP_DROP => stack_opcode!(stack: drop 1), + opcodes::Ordinary::OP_DUP => stack_opcode!(stack: copy 1), + opcodes::Ordinary::OP_NIP => stack_opcode!(stack: drop 2), + opcodes::Ordinary::OP_OVER => stack_opcode!(stack: copy 2), opcodes::Ordinary::OP_PICK => { let n = match stack.pop() { Some(data) => try!(read_scriptint(&data[..])), @@ -2065,7 +2033,7 @@ impl Script { }; if n < 0 { return Err(Error::NegativePick); } let n = n as usize; - stack_opcode!(stack(n + 1): copy (n + 1)) + stack_opcode!(stack: copy (n + 1)) } opcodes::Ordinary::OP_ROLL => { let n = match stack.pop() { @@ -2074,16 +2042,16 @@ impl Script { }; if n < 0 { return Err(Error::NegativeRoll); } let n = n as usize; - stack_opcode!(stack(n + 1): copy (n + 1); drop (n + 1)) + stack_opcode!(stack: copy (n + 1); drop (n + 1)) } - opcodes::Ordinary::OP_ROT => stack_opcode!(stack(3): perm (1, 2, 3)), - opcodes::Ordinary::OP_SWAP => stack_opcode!(stack(2): swap (1, 2)), - opcodes::Ordinary::OP_TUCK => stack_opcode!(stack(2): copy 2; copy 1; drop 2), + opcodes::Ordinary::OP_ROT => stack_opcode!(stack: perm (1, 2, 3)), + opcodes::Ordinary::OP_SWAP => stack_opcode!(stack: swap (1, 2)), + opcodes::Ordinary::OP_TUCK => stack_opcode!(stack: copy 2; copy 1; drop 2), opcodes::Ordinary::OP_IFDUP => { match stack.last().map(|v| read_scriptbool(&v[..])) { None => { return Err(Error::IfEmptyStack); } Some(false) => {} - Some(true) => { stack_opcode!(stack(1): copy 1); } + Some(true) => { stack_opcode!(stack: copy 1); } } } opcodes::Ordinary::OP_DEPTH => { @@ -2268,8 +2236,7 @@ impl Script { /// Whether a script can be proven to have no satisfying input pub fn is_provably_unspendable(&self) -> bool { match self.satisfy() { - Ok(_) => false, - Err(Error::Unanalyzable) => false, + Ok(_) | Err(Error::Unanalyzable) => false, Err(_) => true } } @@ -2343,7 +2310,7 @@ impl Script { index += 4 + n; } // If-statements take effect when not executing - (false, opcodes::Class::Ordinary(opcodes::Ordinary::OP_IF)) => exec_stack.push(false), + (false, opcodes::Class::Ordinary(opcodes::Ordinary::OP_IF)) | (false, opcodes::Class::Ordinary(opcodes::Ordinary::OP_NOTIF)) => exec_stack.push(false), (false, opcodes::Class::Ordinary(opcodes::Ordinary::OP_ELSE)) => { match exec_stack.last_mut() { @@ -2374,9 +2341,8 @@ impl Script { let mut stack_true = stack.clone(); // Try pushing false and see what happens if stack.peek_mut().set_bool_value(false).is_ok() { - match recurse(&script[index - 1..], stack, exec_stack.clone(), depth + 1) { - Ok(res) => { return Ok(res); } - Err(_) => {} + if let Ok(res) = recurse(&script[index - 1..], stack, exec_stack.clone(), depth + 1) { + return Ok(res); } } // Failing that, push true @@ -2399,9 +2365,8 @@ impl Script { let mut stack_true = stack.clone(); // Try pushing false and see what happens if stack.peek_mut().set_bool_value(false).is_ok() { - match recurse(&script[index - 1..], stack, exec_stack.clone(), depth + 1) { - Ok(res) => { return Ok(res); } - Err(_) => {} + if let Ok(res) = recurse(&script[index - 1..], stack, exec_stack.clone(), depth + 1) { + return Ok(res); } } // Failing that, push true @@ -2428,20 +2393,20 @@ impl Script { opcodes::Ordinary::OP_VERIFY => op_verify_satisfy!(stack), opcodes::Ordinary::OP_TOALTSTACK => { stack.top_to_altstack(); } opcodes::Ordinary::OP_FROMALTSTACK => { try!(stack.top_from_altstack()); } - opcodes::Ordinary::OP_2DROP => stack_opcode!(stack(2): require 2; drop 1; drop 2), - opcodes::Ordinary::OP_2DUP => stack_opcode!(stack(2): require 2; copy 2; copy 1), - opcodes::Ordinary::OP_3DUP => stack_opcode!(stack(3): require 3; copy 3; copy 2; copy 1), - opcodes::Ordinary::OP_2OVER => stack_opcode!(stack(4): require 4; copy 4; copy 3), - opcodes::Ordinary::OP_2ROT => stack_opcode!(stack(6): require 6; - perm (1, 3, 5); - perm (2, 4, 6)), - opcodes::Ordinary::OP_2SWAP => stack_opcode!(stack(4): require 4; - swap (2, 4); - swap (1, 3)), - opcodes::Ordinary::OP_DROP => stack_opcode!(stack(1): require 1; drop 1), - opcodes::Ordinary::OP_DUP => stack_opcode!(stack(1): require 1; copy 1), - opcodes::Ordinary::OP_NIP => stack_opcode!(stack(2): require 2; drop 2), - opcodes::Ordinary::OP_OVER => stack_opcode!(stack(2): require 2; copy 2), + opcodes::Ordinary::OP_2DROP => stack_opcode!(stack: require 2; drop 1; drop 2), + opcodes::Ordinary::OP_2DUP => stack_opcode!(stack: require 2; copy 2; copy 1), + opcodes::Ordinary::OP_3DUP => stack_opcode!(stack: require 3; copy 3; copy 2; copy 1), + opcodes::Ordinary::OP_2OVER => stack_opcode!(stack: require 4; copy 4; copy 3), + opcodes::Ordinary::OP_2ROT => stack_opcode!(stack: require 6; + perm (1, 3, 5); + perm (2, 4, 6)), + opcodes::Ordinary::OP_2SWAP => stack_opcode!(stack: require 4; + swap (2, 4); + swap (1, 3)), + opcodes::Ordinary::OP_DROP => stack_opcode!(stack: require 1; drop 1), + opcodes::Ordinary::OP_DUP => stack_opcode!(stack: require 1; copy 1), + opcodes::Ordinary::OP_NIP => stack_opcode!(stack: require 2; drop 2), + opcodes::Ordinary::OP_OVER => stack_opcode!(stack: require 2; copy 2), opcodes::Ordinary::OP_PICK => { let top_n = { let top = stack.peek_mut(); @@ -2451,7 +2416,7 @@ impl Script { }; stack.pop(); match top_n { - Some(n) => stack_opcode!(stack(n + 1): require (n + 1); copy (n + 1)), + Some(n) => stack_opcode!(stack: require (n + 1); copy (n + 1)), // The stack will wind up with the 1 and nth inputs being identical // with n input-dependent. I can imagine scripts which check this // condition or its negation for various n to get arbitrary finite @@ -2469,7 +2434,7 @@ impl Script { }; stack.pop(); match top_n { - Some(n) => stack_opcode!(stack(n + 1): require (n + 1); copy (n + 1); drop (n + 1)), + Some(n) => stack_opcode!(stack: require (n + 1); copy (n + 1); drop (n + 1)), // The stack will wind up reordered, so in principle I could just force // the input to be zero (other n values can be converted to zero by just // manually rearranging the input). The problem is if numeric bounds are @@ -2477,9 +2442,9 @@ impl Script { None => { return Err(Error::Unanalyzable); } } } - opcodes::Ordinary::OP_ROT => stack_opcode!(stack(3): require 3; perm (1, 2, 3)), - opcodes::Ordinary::OP_SWAP => stack_opcode!(stack(2): require 3; swap (1, 2)), - opcodes::Ordinary::OP_TUCK => stack_opcode!(stack(2): require 2; copy 2; copy 1; drop 2), + opcodes::Ordinary::OP_ROT => stack_opcode!(stack: require 3; perm (1, 2, 3)), + opcodes::Ordinary::OP_SWAP => stack_opcode!(stack: require 3; swap (1, 2)), + opcodes::Ordinary::OP_TUCK => stack_opcode!(stack: require 2; copy 2; copy 1; drop 2), opcodes::Ordinary::OP_IFDUP => { let top_bool = { let top = stack.peek_mut(); @@ -2487,14 +2452,13 @@ impl Script { }; match top_bool { Some(false) => { } - Some(true) => { stack_opcode!(stack(1): require 1; copy 1); } + Some(true) => { stack_opcode!(stack: require 1; copy 1); } None => { let mut stack_true = stack.clone(); // Try pushing false and see what happens if stack.peek_mut().set_bool_value(false).is_ok() { - match recurse(&script[index - 1..], stack, exec_stack.clone(), depth + 1) { - Ok(res) => { return Ok(res); } - Err(_) => {} + if let Ok(res) = recurse(&script[index - 1..], stack, exec_stack.clone(), depth + 1) { + return Ok(res); } } // Failing that, push true diff --git a/src/internal_macros.rs b/src/internal_macros.rs index b0280896..7466f5f7 100644 --- a/src/internal_macros.rs +++ b/src/internal_macros.rs @@ -195,8 +195,8 @@ macro_rules! impl_array_newtype_encodable { unsafe { use std::mem; let mut ret: [$ty; $len] = mem::uninitialized(); - for i in 0..$len { - ret[i] = match try!(v.visit()) { + for item in ret.mut_iter() { + *item = match try!(v.visit()) { Some(c) => c, None => return Err(::serde::de::Error::end_of_stream_error()) }; diff --git a/src/network/encodable.rs b/src/network/encodable.rs index 5dd3cd41..3453bef6 100644 --- a/src/network/encodable.rs +++ b/src/network/encodable.rs @@ -150,7 +150,7 @@ macro_rules! impl_array { // Set everything to the first decode let mut ret = [try!(ConsensusDecodable::consensus_decode(d)); $size]; // Set the rest - for i in 1..$size { ret[i] = try!(ConsensusDecodable::consensus_decode(d)); } + for item in ret.iter_mut().take($size).skip(1) { *item = try!(ConsensusDecodable::consensus_decode(d)); } Ok(ret) } } diff --git a/src/util/contracthash.rs b/src/util/contracthash.rs index 3e1f34f7..b4a2b36f 100644 --- a/src/util/contracthash.rs +++ b/src/util/contracthash.rs @@ -59,7 +59,7 @@ pub enum Error { impl fmt::Display for Error { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match *self { - Error::BadTweak(ref e) => fmt::Display::fmt(&e, f), + Error::BadTweak(ref e) | Error::Secp(ref e) => fmt::Display::fmt(&e, f), Error::Script(ref e) => fmt::Display::fmt(&e, f), Error::UncompressedKey => f.write_str("encountered uncompressed secp public key"), @@ -74,7 +74,7 @@ impl fmt::Display for Error { impl error::Error for Error { fn cause(&self) -> Option<&error::Error> { match *self { - Error::BadTweak(ref e) => Some(e), + Error::BadTweak(ref e) | Error::Secp(ref e) => Some(e), Error::Script(ref e) => Some(e), _ => None @@ -175,7 +175,7 @@ pub fn tweak_secret_key(secp: &Secp256k1, key: &SecretKey, contract: &[u8]) -> R hmac.raw_result(&mut hmac_raw); let hmac_sk = try!(SecretKey::from_slice(&secp, &hmac_raw).map_err(Error::BadTweak)); // Execute the tweak - let mut key = key.clone(); + let mut key = *key; try!(key.add_assign(&secp, &hmac_sk).map_err(Error::Secp)); // Return Ok(key) diff --git a/src/util/hash.rs b/src/util/hash.rs index 395bf869..f635bc59 100644 --- a/src/util/hash.rs +++ b/src/util/hash.rs @@ -167,7 +167,7 @@ impl Sha256dHash { /// Decodes a big-endian (i.e. reversed vs sha256sum output) hex string as a Sha256dHash #[inline] - pub fn from_hex<'a>(s: &'a str) -> Result { + pub fn from_hex(s: &str) -> Result { if s.len() != 64 { return Err(HexError::BadLength(s.len())); } @@ -204,9 +204,9 @@ impl Sha256dHash { pub fn le_hex_string(&self) -> String { let &Sha256dHash(data) = self; let mut ret = String::with_capacity(64); - for i in 0..32 { - ret.push(from_digit((data[i] / 0x10) as u32, 16).unwrap()); - ret.push(from_digit((data[i] & 0x0f) as u32, 16).unwrap()); + for item in data.iter().take(32) { + ret.push(from_digit((*item / 0x10) as u32, 16).unwrap()); + ret.push(from_digit((*item & 0x0f) as u32, 16).unwrap()); } ret } diff --git a/src/util/patricia_tree.rs b/src/util/patricia_tree.rs index 23de852a..5be2e2be 100644 --- a/src/util/patricia_tree.rs +++ b/src/util/patricia_tree.rs @@ -345,7 +345,7 @@ impl PatriciaTree } /// Returns an iterator over all elements in the tree - pub fn iter<'a>(&'a self) -> Items<'a, K, V> { + pub fn iter(&self) -> Items { Items { node: Some(self), parents: vec![], @@ -354,7 +354,7 @@ impl PatriciaTree } /// Returns a mutable iterator over all elements in the tree - pub fn mut_iter<'a>(&'a mut self) -> MutItems<'a, K, V> { + pub fn mut_iter(&mut self) -> MutItems { MutItems { node: self as *mut _, parents: vec![],