Qortal/pirate-librustzcash
1
0
Fork 0
mirror of https://github.com/Qortal/pirate-librustzcash.git synced 2025-07-30 03:51:22 +00:00
Code Issues Packages Projects Releases Wiki Activity

cargo fmt

Browse Source
This commit is contained in:
Sean Bowe
2020-03-03 18:11:44 -07:00
parent 5e1a2f9d3f
commit 46e88a5e69
9 changed files with 173 additions and 172 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
librustzcash/src/tests/mmr.rs
View File

@@ -135,8 +135,8 @@ fn load_nodes(bytes: &'static [u8]) -> Vec<NodeData> {
let mut res = Vec::new(); let mut res = Vec::new();
let mut cursor = std::io::Cursor::new(bytes); let mut cursor = std::io::Cursor::new(bytes);
while (cursor.position() as usize) < bytes.len() { while (cursor.position() as usize) < bytes.len() {
let node_data = let node_data = zcash_history::NodeData::read(0, &mut cursor)
zcash_history::NodeData::read(0, &mut cursor).expect("Statically checked to be correct"); .expect("Statically checked to be correct");
res.push(node_data); res.push(node_data);
} }

4
zcash_history/examples/lib/main.rs
View File

@@ -1,4 +1,2 @@
// dummy example // dummy example
pub fn main() { pub fn main() {}
}

40
zcash_history/examples/lib/shared.rs
View File

@@ -1,4 +1,4 @@
use zcash_history:: {NodeData, Tree, Entry, EntryLink}; use zcash_history::{Entry, EntryLink, NodeData, Tree};
pub struct NodeDataIterator { pub struct NodeDataIterator {
return_stack: Vec<NodeData>, return_stack: Vec<NodeData>,
@@ -22,11 +22,20 @@ impl Iterator for NodeDataIterator {
} else if self.return_stack.len() > 0 { } else if self.return_stack.len() > 0 {
self.return_stack.pop() self.return_stack.pop()
} else { } else {
for n_append in for n_append in self
self.tree.append_leaf(leaf(self.leaf_cursor as u32)) .tree
.expect("full tree cannot fail").into_iter().rev() .append_leaf(leaf(self.leaf_cursor as u32))
.expect("full tree cannot fail")
.into_iter()
.rev()
{ {
self.return_stack.push(self.tree.resolve_link(n_append).expect("just pushed").data().clone()) self.return_stack.push(
self.tree
.resolve_link(n_append)
.expect("just pushed")
.data()
.clone(),
)
} }
self.leaf_cursor += 1; self.leaf_cursor += 1;
self.return_stack.pop() self.return_stack.pop()
@@ -42,14 +51,13 @@ impl NodeDataIterator {
let root = Entry::new( let root = Entry::new(
NodeData::combine(&leaf(1), &leaf(2)), NodeData::combine(&leaf(1), &leaf(2)),
EntryLink::Stored(0), EntryLink::Stored(0),
EntryLink::Stored(1) EntryLink::Stored(1),
);
let tree = Tree::new(
3,
vec![(2, root)],
vec![(0, leaf(1).into()), (1, leaf(2).into())],
); );
let tree =
Tree::new(
3,
vec![(2, root)],
vec![(0, leaf(1).into()), (1, leaf(2).into())]
);
NodeDataIterator { NodeDataIterator {
return_stack: Vec::new(), return_stack: Vec::new(),
@@ -64,10 +72,10 @@ fn leaf(height: u32) -> NodeData {
NodeData { NodeData {
consensus_branch_id: 0, consensus_branch_id: 0,
subtree_commitment: [0u8; 32], subtree_commitment: [0u8; 32],
start_time: height*10+1, start_time: height * 10 + 1,
end_time: (height+1)*10, end_time: (height + 1) * 10,
start_target: 100 + height*10, start_target: 100 + height * 10,
end_target: 100 + (height+1)*10, end_target: 100 + (height + 1) * 10,
start_sapling_root: [0u8; 32], start_sapling_root: [0u8; 32],
end_sapling_root: [0u8; 32], end_sapling_root: [0u8; 32],
subtree_total_work: 0.into(), subtree_total_work: 0.into(),

40
zcash_history/examples/long.rs
View File

@@ -1,10 +1,10 @@
use zcash_history::{Entry, EntryLink, NodeData, Tree}; use zcash_history::{Entry, EntryLink, NodeData, Tree};
#[path= "lib/shared.rs"] #[path = "lib/shared.rs"]
mod share; mod share;
fn draft(into: &mut Vec<(u32, Entry)>, vec: &Vec<NodeData>, peak_pos: usize, h: u32) { fn draft(into: &mut Vec<(u32, Entry)>, vec: &Vec<NodeData>, peak_pos: usize, h: u32) {
let node_data = vec[peak_pos-1].clone(); let node_data = vec[peak_pos - 1].clone();
let peak: Entry = match h { let peak: Entry = match h {
0 => node_data.into(), 0 => node_data.into(),
_ => Entry::new( _ => Entry::new(
@@ -16,16 +16,15 @@ fn draft(into: &mut Vec<(u32, Entry)>, vec: &Vec<NodeData>, peak_pos: usize, h:
println!("Entry #{}: {}", into.len(), peak); println!("Entry #{}: {}", into.len(), peak);
into.push(((peak_pos-1) as u32, peak)); into.push(((peak_pos - 1) as u32, peak));
} }
fn prepare_tree(vec: &Vec<NodeData>) -> Tree { fn prepare_tree(vec: &Vec<NodeData>) -> Tree {
assert!(vec.len() > 0); assert!(vec.len() > 0);
// integer log2 of (vec.len()+1), -1 // integer log2 of (vec.len()+1), -1
let mut h = (32 - ((vec.len()+1) as u32).leading_zeros() - 1)-1; let mut h = (32 - ((vec.len() + 1) as u32).leading_zeros() - 1) - 1;
let mut peak_pos = (1 << (h+1)) - 1; let mut peak_pos = (1 << (h + 1)) - 1;
let mut nodes = Vec::new(); let mut nodes = Vec::new();
// used later // used later
@@ -33,10 +32,9 @@ fn prepare_tree(vec: &Vec<NodeData>) -> Tree {
let mut last_peak_h = 0; let mut last_peak_h = 0;
loop { loop {
if peak_pos > vec.len() { if peak_pos > vec.len() {
// left child, -2^h // left child, -2^h
peak_pos = peak_pos - (1<<h); peak_pos = peak_pos - (1 << h);
h = h - 1; h = h - 1;
} }
@@ -48,7 +46,7 @@ fn prepare_tree(vec: &Vec<NodeData>) -> Tree {
last_peak_h = h; last_peak_h = h;
// right sibling // right sibling
peak_pos = peak_pos + (1 << (h+1)) - 1; peak_pos = peak_pos + (1 << (h + 1)) - 1;
} }
if h == 0 { if h == 0 {
@@ -62,7 +60,7 @@ fn prepare_tree(vec: &Vec<NodeData>) -> Tree {
let mut peak_pos = last_peak_pos; let mut peak_pos = last_peak_pos;
while h > 0 { while h > 0 {
let left_pos = peak_pos - (1<<h); let left_pos = peak_pos - (1 << h);
let right_pos = peak_pos - 1; let right_pos = peak_pos - 1;
h = h - 1; h = h - 1;
@@ -82,14 +80,16 @@ fn prepare_tree(vec: &Vec<NodeData>) -> Tree {
} }
fn main() { fn main() {
let number= match std::env::args().skip(1).next() { let number = match std::env::args().skip(1).next() {
None => { eprintln!("writer <number of nodes> [<out_file>]"); std::process::exit(1); }, None => {
Some(number) => { eprintln!("writer <number of nodes> [<out_file>]");
number.parse::<usize>().expect("invalid number") std::process::exit(1);
} }
Some(number) => number.parse::<usize>().expect("invalid number"),
}; };
let long_vec = share::NodeDataIterator::new().take(number) let long_vec = share::NodeDataIterator::new()
.take(number)
.collect::<Vec<NodeData>>(); .collect::<Vec<NodeData>>();
let now = std::time::Instant::now(); let now = std::time::Instant::now();
@@ -97,13 +97,17 @@ fn main() {
let tree = prepare_tree(&long_vec); let tree = prepare_tree(&long_vec);
let elapsed = now.elapsed(); let elapsed = now.elapsed();
println!("Tree final root: {}-{}", println!(
"Tree final root: {}-{}",
tree.root_node().expect("root").data().start_height, tree.root_node().expect("root").data().start_height,
tree.root_node().expect("root").data().end_height, tree.root_node().expect("root").data().end_height,
); );
println!("Prepare tree of {} length: {} ns / {} mcs / {} ms", println!(
"Prepare tree of {} length: {} ns / {} mcs / {} ms",
number, number,
elapsed.as_nanos(), elapsed.as_micros(), elapsed.as_millis() elapsed.as_nanos(),
elapsed.as_micros(),
elapsed.as_millis()
); );
} }

19
zcash_history/examples/write.rs
View File

@@ -1,4 +1,4 @@
#[path= "lib/shared.rs"] #[path = "lib/shared.rs"]
mod share; mod share;
// Test data generator // Test data generator
@@ -11,10 +11,14 @@ fn main() {
let mut args = std::env::args().skip(1); let mut args = std::env::args().skip(1);
let (number, out_file) = match args.next() { let (number, out_file) = match args.next() {
None => { eprintln!("writer <number of nodes> [<out_file>]"); std::process::exit(1); }, None => {
Some(number) => { eprintln!("writer <number of nodes> [<out_file>]");
(number.parse::<usize>().expect("invalid number"), args.next()) std::process::exit(1);
} }
Some(number) => (
number.parse::<usize>().expect("invalid number"),
args.next(),
),
}; };
let iterator = share::NodeDataIterator::new().take(number); let iterator = share::NodeDataIterator::new().take(number);
@@ -24,12 +28,11 @@ fn main() {
let mut buf = Vec::new(); let mut buf = Vec::new();
for node in iterator{ for node in iterator {
node.write(&mut buf).expect("Failed to write data"); node.write(&mut buf).expect("Failed to write data");
} }
let mut file = std::fs::File::create(&out_file_path) let mut file = std::fs::File::create(&out_file_path).expect("Failed to create output file");
.expect("Failed to create output file");
file.write_all(&buf[..]) file.write_all(&buf[..])
.expect("Failed to write data to file"); .expect("Failed to write data to file");
@@ -38,4 +41,4 @@ fn main() {
println!("{:?}", n); println!("{:?}", n);
} }
} }
} }

44
zcash_history/src/entry.rs
View File

@@ -1,6 +1,6 @@
use byteorder::{LittleEndian, ReadBytesExt, WriteBytesExt}; use byteorder::{LittleEndian, ReadBytesExt, WriteBytesExt};
use crate::{EntryKind, NodeData, Error, EntryLink, MAX_NODE_DATA_SIZE}; use crate::{EntryKind, EntryLink, Error, NodeData, MAX_NODE_DATA_SIZE};
/// Max serialized length of entry data. /// Max serialized length of entry data.
pub const MAX_ENTRY_SIZE: usize = MAX_NODE_DATA_SIZE + 9; pub const MAX_ENTRY_SIZE: usize = MAX_NODE_DATA_SIZE + 9;
@@ -34,22 +34,26 @@ impl Entry {
/// Is this node a leaf. /// Is this node a leaf.
pub fn leaf(&self) -> bool { pub fn leaf(&self) -> bool {
if let EntryKind::Leaf = self.kind { true } else { false } if let EntryKind::Leaf = self.kind {
true
} else {
false
}
} }
/// Left child /// Left child
pub fn left(&self) -> Result<EntryLink, Error> { pub fn left(&self) -> Result<EntryLink, Error> {
match self.kind { match self.kind {
EntryKind::Leaf => { Err(Error::node_expected()) } EntryKind::Leaf => Err(Error::node_expected()),
EntryKind::Node(left, _) => Ok(left) EntryKind::Node(left, _) => Ok(left),
} }
} }
/// Right child. /// Right child.
pub fn right(&self) -> Result<EntryLink, Error> { pub fn right(&self) -> Result<EntryLink, Error> {
match self.kind { match self.kind {
EntryKind::Leaf => { Err(Error::node_expected()) } EntryKind::Leaf => Err(Error::node_expected()),
EntryKind::Node(_, right) => Ok(right) EntryKind::Node(_, right) => Ok(right),
} }
} }
@@ -61,22 +65,15 @@ impl Entry {
let left = r.read_u32::<LittleEndian>()?; let left = r.read_u32::<LittleEndian>()?;
let right = r.read_u32::<LittleEndian>()?; let right = r.read_u32::<LittleEndian>()?;
EntryKind::Node(EntryLink::Stored(left), EntryLink::Stored(right)) EntryKind::Node(EntryLink::Stored(left), EntryLink::Stored(right))
}, }
1 => { 1 => EntryKind::Leaf,
EntryKind::Leaf _ => return Err(std::io::Error::from(std::io::ErrorKind::InvalidData)),
},
_ => {
return Err(std::io::Error::from(std::io::ErrorKind::InvalidData))
},
} }
}; };
let data = NodeData::read(consensus_branch_id, r)?; let data = NodeData::read(consensus_branch_id, r)?;
Ok(Entry { Ok(Entry { kind, data })
kind,
data,
})
} }
/// Write to byte representation. /// Write to byte representation.
@@ -86,11 +83,13 @@ impl Entry {
w.write_u8(0)?; w.write_u8(0)?;
w.write_u32::<LittleEndian>(left)?; w.write_u32::<LittleEndian>(left)?;
w.write_u32::<LittleEndian>(right)?; w.write_u32::<LittleEndian>(right)?;
}, }
EntryKind::Leaf => { EntryKind::Leaf => {
w.write_u8(1)?; w.write_u8(1)?;
}, }
_ => { return Err(std::io::Error::from(std::io::ErrorKind::InvalidData)); } _ => {
return Err(std::io::Error::from(std::io::ErrorKind::InvalidData));
}
} }
self.data.write(w)?; self.data.write(w)?;
@@ -107,7 +106,10 @@ impl Entry {
impl From<NodeData> for Entry { impl From<NodeData> for Entry {
fn from(s: NodeData) -> Self { fn from(s: NodeData) -> Self {
Entry { kind: EntryKind::Leaf, data: s } Entry {
kind: EntryKind::Leaf,
data: s,
}
} }
} }

22
zcash_history/src/lib.rs
View File

@@ -3,14 +3,13 @@
//! To be used in zebra and via FFI bindings in zcashd //! To be used in zebra and via FFI bindings in zcashd
#![warn(missing_docs)] #![warn(missing_docs)]
mod tree;
mod node_data;
mod entry; mod entry;
mod node_data;
mod tree;
pub use tree::Tree;
pub use node_data::{NodeData, MAX_NODE_DATA_SIZE};
pub use entry::{Entry, MAX_ENTRY_SIZE}; pub use entry::{Entry, MAX_ENTRY_SIZE};
pub use node_data::{NodeData, MAX_NODE_DATA_SIZE};
pub use tree::Tree;
/// Crate-level error type /// Crate-level error type
#[derive(Debug)] #[derive(Debug)]
@@ -62,16 +61,19 @@ pub enum EntryKind {
impl Error { impl Error {
/// Entry expected to be a node (specifying for which link this is not true). /// Entry expected to be a node (specifying for which link this is not true).
pub fn link_node_expected(link: EntryLink) -> Self { Self::ExpectedNode(Some(link)) } pub fn link_node_expected(link: EntryLink) -> Self {
Self::ExpectedNode(Some(link))
}
/// Some entry is expected to be node /// Some entry is expected to be node
pub fn node_expected() -> Self { Self::ExpectedNode(None) } pub fn node_expected() -> Self {
Self::ExpectedNode(None)
}
pub (crate) fn augment(self, link: EntryLink) -> Self { pub(crate) fn augment(self, link: EntryLink) -> Self {
match self { match self {
Error::ExpectedNode(_) => Error::ExpectedNode(Some(link)), Error::ExpectedNode(_) => Error::ExpectedNode(Some(link)),
val => val val => val,
} }
} }
} }

33
zcash_history/src/node_data.rs
View File

@@ -1,10 +1,9 @@
use byteorder::{LittleEndian, ReadBytesExt, WriteBytesExt, ByteOrder};
use bigint::U256; use bigint::U256;
use blake2::Params as Blake2Params; use blake2::Params as Blake2Params;
use byteorder::{ByteOrder, LittleEndian, ReadBytesExt, WriteBytesExt};
/// Maximum serialized size of the node metadata. /// Maximum serialized size of the node metadata.
pub const MAX_NODE_DATA_SIZE: usize = pub const MAX_NODE_DATA_SIZE: usize = 32 + // subtree commitment
32 + // subtree commitment
4 + // start time 4 + // start time
4 + // end time 4 + // end time
4 + // start target 4 + // start target
@@ -14,8 +13,8 @@ pub const MAX_NODE_DATA_SIZE: usize =
32 + // subtree total work 32 + // subtree total work
9 + // start height (compact uint) 9 + // start height (compact uint)
9 + // end height (compact uint) 9 + // end height (compact uint)
9; // shielded tx count (compact uint) 9; // shielded tx count (compact uint)
// = total of 171 // = total of 171
/// Node metadata. /// Node metadata.
#[repr(C)] #[repr(C)]
@@ -75,14 +74,17 @@ impl NodeData {
let mut hash_buf = [0u8; MAX_NODE_DATA_SIZE * 2]; let mut hash_buf = [0u8; MAX_NODE_DATA_SIZE * 2];
let size = { let size = {
let mut cursor = ::std::io::Cursor::new(&mut hash_buf[..]); let mut cursor = ::std::io::Cursor::new(&mut hash_buf[..]);
left.write(&mut cursor).expect("Writing to memory buf with enough length cannot fail; qed"); left.write(&mut cursor)
right.write(&mut cursor).expect("Writing to memory buf with enough length cannot fail; qed"); .expect("Writing to memory buf with enough length cannot fail; qed");
right
.write(&mut cursor)
.expect("Writing to memory buf with enough length cannot fail; qed");
cursor.position() as usize cursor.position() as usize
}; };
let hash = blake2b_personal( let hash = blake2b_personal(
&personalization(left.consensus_branch_id), &personalization(left.consensus_branch_id),
&hash_buf[..size] &hash_buf[..size],
); );
NodeData { NodeData {
@@ -103,17 +105,15 @@ impl NodeData {
fn write_compact<W: std::io::Write>(w: &mut W, compact: u64) -> std::io::Result<()> { fn write_compact<W: std::io::Write>(w: &mut W, compact: u64) -> std::io::Result<()> {
match compact { match compact {
0..=0xfc => { 0..=0xfc => w.write_all(&[compact as u8])?,
w.write_all(&[compact as u8])?
},
0xfd..=0xffff => { 0xfd..=0xffff => {
w.write_all(&[0xfd])?; w.write_all(&[0xfd])?;
w.write_u16::<LittleEndian>(compact as u16)?; w.write_u16::<LittleEndian>(compact as u16)?;
}, }
0x10000..=0xffff_ffff => { 0x10000..=0xffff_ffff => {
w.write_all(&[0xfe])?; w.write_all(&[0xfe])?;
w.write_u32::<LittleEndian>(compact as u32)?; w.write_u32::<LittleEndian>(compact as u32)?;
}, }
_ => { _ => {
w.write_all(&[0xff])?; w.write_all(&[0xff])?;
w.write_u64::<LittleEndian>(compact)?; w.write_u64::<LittleEndian>(compact)?;
@@ -160,8 +160,8 @@ impl NodeData {
r.read_exact(&mut data.subtree_commitment)?; r.read_exact(&mut data.subtree_commitment)?;
data.start_time = r.read_u32::<LittleEndian>()?; data.start_time = r.read_u32::<LittleEndian>()?;
data.end_time = r.read_u32::<LittleEndian>()?; data.end_time = r.read_u32::<LittleEndian>()?;
data.start_target= r.read_u32::<LittleEndian>()?; data.start_target = r.read_u32::<LittleEndian>()?;
data.end_target= r.read_u32::<LittleEndian>()?; data.end_target = r.read_u32::<LittleEndian>()?;
r.read_exact(&mut data.start_sapling_root)?; r.read_exact(&mut data.start_sapling_root)?;
r.read_exact(&mut data.end_sapling_root)?; r.read_exact(&mut data.end_sapling_root)?;
@@ -230,10 +230,9 @@ mod tests {
use super::NodeData; use super::NodeData;
use quickcheck::{quickcheck, TestResult}; use quickcheck::{quickcheck, TestResult};
quickcheck! { quickcheck! {
fn serialization_round_trip(node_data: NodeData) -> TestResult { fn serialization_round_trip(node_data: NodeData) -> TestResult {
TestResult::from_bool(NodeData::from_bytes(0, &node_data.to_bytes()).unwrap() == node_data) TestResult::from_bool(NodeData::from_bytes(0, &node_data.to_bytes()).unwrap() == node_data)
} }
} }
} }

139
zcash_history/src/tree.rs
View File

@@ -1,6 +1,6 @@
use std::collections::HashMap; use std::collections::HashMap;
use crate::{Entry, EntryLink, NodeData, Error, EntryKind}; use crate::{Entry, EntryKind, EntryLink, Error, NodeData};
/// Represents partially loaded tree. /// Represents partially loaded tree.
/// ///
@@ -28,15 +28,12 @@ pub struct Tree {
impl Tree { impl Tree {
/// Resolve link originated from this tree /// Resolve link originated from this tree
pub fn resolve_link(&self, link: EntryLink) -> Result<IndexedNode, Error> { pub fn resolve_link(&self, link: EntryLink) -> Result<IndexedNode, Error> {
match link { match link {
EntryLink::Generated(index) => self.generated.get(index as usize), EntryLink::Generated(index) => self.generated.get(index as usize),
EntryLink::Stored(index) => self.stored.get(&index), EntryLink::Stored(index) => self.stored.get(&index),
} }
.map(|node| IndexedNode { .map(|node| IndexedNode { node, link })
node, .ok_or(Error::ExpectedInMemory(link))
link,
})
.ok_or(Error::ExpectedInMemory(link))
} }
fn push(&mut self, data: Entry) -> EntryLink { fn push(&mut self, data: Entry) -> EntryLink {
@@ -86,11 +83,7 @@ impl Tree {
/// # Panics /// # Panics
/// ///
/// Will panic if `peaks` is empty. /// Will panic if `peaks` is empty.
pub fn new( pub fn new(length: u32, peaks: Vec<(u32, Entry)>, extra: Vec<(u32, Entry)>) -> Self {
length: u32,
peaks: Vec<(u32, Entry)>,
extra: Vec<(u32, Entry)>,
) -> Self {
assert!(peaks.len() > 0); assert!(peaks.len() > 0);
let mut result = Tree::invalid(); let mut result = Tree::invalid();
@@ -102,11 +95,14 @@ impl Tree {
for (idx, node) in peaks.into_iter() { for (idx, node) in peaks.into_iter() {
result.stored.insert(idx, node); result.stored.insert(idx, node);
if gen != 0 { if gen != 0 {
let next_generated = let next_generated = combine_nodes(
combine_nodes(result. result
resolve_link(root).expect("Inserted before, cannot fail; qed"), .resolve_link(root)
result.resolve_link(EntryLink::Stored(idx)).expect("Inserted before, cannot fail; qed") .expect("Inserted before, cannot fail; qed"),
); result
.resolve_link(EntryLink::Stored(idx))
.expect("Inserted before, cannot fail; qed"),
);
root = result.push_generated(next_generated); root = result.push_generated(next_generated);
} }
gen += 1; gen += 1;
@@ -122,17 +118,13 @@ impl Tree {
} }
fn get_peaks(&self, root: EntryLink, target: &mut Vec<EntryLink>) -> Result<(), Error> { fn get_peaks(&self, root: EntryLink, target: &mut Vec<EntryLink>) -> Result<(), Error> {
let (left_child_link, right_child_link) = { let (left_child_link, right_child_link) = {
let root = self.resolve_link(root)?; let root = self.resolve_link(root)?;
if root.node.complete() { if root.node.complete() {
target.push(root.link); target.push(root.link);
return Ok(()); return Ok(());
} }
( (root.left()?, root.right()?)
root.left()?,
root.right()?,
)
}; };
self.get_peaks(left_child_link, target)?; self.get_peaks(left_child_link, target)?;
@@ -161,14 +153,18 @@ impl Tree {
// complete subtrees. After this, merge_stack only contains peaks of // complete subtrees. After this, merge_stack only contains peaks of
// unequal-sized subtrees. // unequal-sized subtrees.
while let Some(next_peak) = peaks.pop() { while let Some(next_peak) = peaks.pop() {
let next_merge = merge_stack.pop().expect("there should be at least one, initial or re-pushed"); let next_merge = merge_stack
.pop()
.expect("there should be at least one, initial or re-pushed");
if let Some(stored) = { if let Some(stored) = {
let peak = self.resolve_link(next_peak)?; let peak = self.resolve_link(next_peak)?;
let m = self.resolve_link(next_merge)?; let m = self.resolve_link(next_merge)?;
if peak.node.leaf_count() == m.node.leaf_count() { if peak.node.leaf_count() == m.node.leaf_count() {
Some(combine_nodes(peak, m)) Some(combine_nodes(peak, m))
} else { None } } else {
None
}
} { } {
let link = self.push(stored); let link = self.push(stored);
merge_stack.push(link); merge_stack.push(link);
@@ -180,16 +176,16 @@ impl Tree {
} }
} }
let mut new_root = merge_stack.pop().expect("Loop above cannot reduce the merge_stack"); let mut new_root = merge_stack
.pop()
.expect("Loop above cannot reduce the merge_stack");
// Scan the peaks left-to-right, producing new generated nodes that // Scan the peaks left-to-right, producing new generated nodes that
// connect the subtrees // connect the subtrees
while let Some(next_child) = merge_stack.pop() { while let Some(next_child) = merge_stack.pop() {
new_root = self.push_generated( new_root = self.push_generated(combine_nodes(
combine_nodes( self.resolve_link(new_root)?,
self.resolve_link(new_root)?, self.resolve_link(next_child)?,
self.resolve_link(next_child)?, ))
)
)
} }
self.root = new_root; self.root = new_root;
@@ -200,7 +196,9 @@ impl Tree {
#[cfg(test)] #[cfg(test)]
fn for_children<F: Fn(EntryLink, EntryLink)>(&self, node: EntryLink, f: F) { fn for_children<F: Fn(EntryLink, EntryLink)>(&self, node: EntryLink, f: F) {
let (left, right) = { let (left, right) = {
let link = self.resolve_link(node).expect("Failed to resolve link in test"); let link = self
.resolve_link(node)
.expect("Failed to resolve link in test");
( (
link.left().expect("Failed to find node in test"), link.left().expect("Failed to find node in test"),
link.right().expect("Failed to find node in test"), link.right().expect("Failed to find node in test"),
@@ -210,7 +208,7 @@ impl Tree {
} }
fn pop(&mut self) { fn pop(&mut self) {
self.stored.remove(&(self.stored_count-1)); self.stored.remove(&(self.stored_count - 1));
self.stored_count = self.stored_count - 1; self.stored_count = self.stored_count - 1;
} }
@@ -222,10 +220,7 @@ impl Tree {
let root = { let root = {
let (leaves, root_left_child) = { let (leaves, root_left_child) = {
let n = self.resolve_link(self.root)?; let n = self.resolve_link(self.root)?;
( (n.node.leaf_count(), n.node.left()?)
n.node.leaf_count(),
n.node.left()?,
)
}; };
if leaves & 1 != 0 { if leaves & 1 != 0 {
self.pop(); self.pop();
@@ -247,7 +242,9 @@ impl Tree {
subtree_root_link = right; subtree_root_link = right;
truncated += 1; truncated += 1;
} else { } else {
if root.node.complete() { truncated += 1; } if root.node.complete() {
truncated += 1;
}
break; break;
} }
} }
@@ -255,15 +252,15 @@ impl Tree {
let mut new_root = *peaks.get(0).expect("At lest 1 elements in peaks"); let mut new_root = *peaks.get(0).expect("At lest 1 elements in peaks");
for next_peak in peaks.into_iter().skip(1) { for next_peak in peaks.into_iter().skip(1) {
new_root = self.push_generated( new_root = self.push_generated(combine_nodes(
combine_nodes(
self.resolve_link(new_root)?, self.resolve_link(new_root)?,
self.resolve_link(next_peak)?, self.resolve_link(next_peak)?,
) ));
);
} }
for _ in 0..truncated { self.pop(); } for _ in 0..truncated {
self.pop();
}
self.root = new_root; self.root = new_root;
@@ -276,7 +273,9 @@ impl Tree {
} }
/// Link to the root node /// Link to the root node
pub fn root(&self) -> EntryLink { self.root } pub fn root(&self) -> EntryLink {
self.root
}
/// Reference to the root node. /// Reference to the root node.
pub fn root_node(&self) -> Result<IndexedNode, Error> { pub fn root_node(&self) -> Result<IndexedNode, Error> {
@@ -297,7 +296,6 @@ pub struct IndexedNode<'a> {
} }
impl<'a> IndexedNode<'a> { impl<'a> IndexedNode<'a> {
fn left(&self) -> Result<EntryLink, Error> { fn left(&self) -> Result<EntryLink, Error> {
self.node.left().map_err(|e| e.augment(self.link)) self.node.left().map_err(|e| e.augment(self.link))
} }
@@ -332,9 +330,9 @@ fn combine_nodes<'a>(left: IndexedNode<'a>, right: IndexedNode<'a>) -> Entry {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::{Entry, NodeData, Tree, EntryLink, EntryKind}; use super::{Entry, EntryKind, EntryLink, NodeData, Tree};
use quickcheck::{quickcheck, TestResult};
use assert_matches::assert_matches; use assert_matches::assert_matches;
use quickcheck::{quickcheck, TestResult};
fn leaf(height: u32) -> NodeData { fn leaf(height: u32) -> NodeData {
NodeData { NodeData {
@@ -370,7 +368,8 @@ mod tests {
assert!(length >= 3); assert!(length >= 3);
let mut tree = initial(); let mut tree = initial();
for i in 2..length { for i in 2..length {
tree.append_leaf(leaf(i+1).into()).expect("Failed to append"); tree.append_leaf(leaf(i + 1).into())
.expect("Failed to append");
} }
tree tree
@@ -381,9 +380,7 @@ mod tests {
let mut tree = initial(); let mut tree = initial();
// ** APPEND 3 ** // ** APPEND 3 **
let appended = tree let appended = tree.append_leaf(leaf(3)).expect("Failed to append");
.append_leaf(leaf(3))
.expect("Failed to append");
let new_root = tree.root_node().expect("Failed to resolve root").node; let new_root = tree.root_node().expect("Failed to resolve root").node;
// initial tree: (2) // initial tree: (2)
@@ -403,9 +400,7 @@ mod tests {
assert_eq!(appended.len(), 1); assert_eq!(appended.len(), 1);
// ** APPEND 4 ** // ** APPEND 4 **
let appended = tree let appended = tree.append_leaf(leaf(4)).expect("Failed to append");
.append_leaf(leaf(4))
.expect("Failed to append");
let new_root = tree.root_node().expect("Failed to resolve root").node; let new_root = tree.root_node().expect("Failed to resolve root").node;
@@ -431,9 +426,7 @@ mod tests {
// ** APPEND 5 ** // ** APPEND 5 **
let appended = tree let appended = tree.append_leaf(leaf(5)).expect("Failed to append");
.append_leaf(leaf(5))
.expect("Failed to append");
let new_root = tree.root_node().expect("Failed to resolve root").node; let new_root = tree.root_node().expect("Failed to resolve root").node;
// intermediate tree: // intermediate tree:
@@ -463,9 +456,7 @@ mod tests {
}); });
// *** APPEND #6 *** // *** APPEND #6 ***
let appended = tree let appended = tree.append_leaf(leaf(6)).expect("Failed to append");
.append_leaf(leaf(6))
.expect("Failed to append");
let new_root = tree.root_node().expect("Failed to resolve root").node; let new_root = tree.root_node().expect("Failed to resolve root").node;
// intermediate tree: // intermediate tree:
@@ -498,13 +489,8 @@ mod tests {
// *** APPEND #7 *** // *** APPEND #7 ***
let appended = tree let appended = tree.append_leaf(leaf(7)).expect("Failed to append");
.append_leaf(leaf(7)) let new_root = tree.root_node().expect("Failed to resolve root").node;
.expect("Failed to append");
let new_root = tree
.root_node()
.expect("Failed to resolve root")
.node;
// intermediate tree: // intermediate tree:
// (---8g---) // (---8g---)
@@ -533,9 +519,9 @@ mod tests {
assert_matches!(tree.root(), EntryLink::Generated(_)); assert_matches!(tree.root(), EntryLink::Generated(_));
tree.for_children(tree.root(), |l, r| { tree.for_children(tree.root(), |l, r| {
assert_matches!(l, EntryLink::Generated(_)); assert_matches!(l, EntryLink::Generated(_));
tree.for_children(l, |l, r| tree.for_children(l, |l, r| {
assert_matches!((l, r), (EntryLink::Stored(6), EntryLink::Stored(9))) assert_matches!((l, r), (EntryLink::Stored(6), EntryLink::Stored(9)))
); });
assert_matches!(r, EntryLink::Stored(10)); assert_matches!(r, EntryLink::Stored(10));
}); });
} }
@@ -606,12 +592,12 @@ mod tests {
assert_matches!(tree.root(), EntryLink::Generated(_)); assert_matches!(tree.root(), EntryLink::Generated(_));
tree.for_children(tree.root(),|left, right| tree.for_children(tree.root(), |left, right| {
assert_matches!( assert_matches!(
(left, right), (left, right),
(EntryLink::Stored(14), EntryLink::Stored(15)) (EntryLink::Stored(14), EntryLink::Stored(15))
) )
); });
// two stored nodes should leave us (leaf 16 and no longer needed node 17) // two stored nodes should leave us (leaf 16 and no longer needed node 17)
assert_eq!(deleted, 2); assert_eq!(deleted, 2);
@@ -625,7 +611,7 @@ mod tests {
assert_eq!(tree.len(), 3); assert_eq!(tree.len(), 3);
for i in 0..2 { for i in 0..2 {
tree.append_leaf(leaf(i+3)).expect("Failed to append"); tree.append_leaf(leaf(i + 3)).expect("Failed to append");
} }
assert_eq!(tree.len(), 7); assert_eq!(tree.len(), 7);
@@ -641,7 +627,7 @@ mod tests {
assert_eq!(tree.len(), 3); assert_eq!(tree.len(), 3);
for i in 0..4094 { for i in 0..4094 {
tree.append_leaf(leaf(i+3)).expect("Failed to append"); tree.append_leaf(leaf(i + 3)).expect("Failed to append");
} }
assert_eq!(tree.len(), 8191); // 4096*2-1 (full tree) assert_eq!(tree.len(), 8191); // 4096*2-1 (full tree)
@@ -652,7 +638,6 @@ mod tests {
assert_eq!(tree.len(), 4083); // 4095 - log2(4096) assert_eq!(tree.len(), 4083); // 4095 - log2(4096)
} }
quickcheck! { quickcheck! {
fn there_and_back(number: u32) -> TestResult { fn there_and_back(number: u32) -> TestResult {
if number > 1024*1024 { if number > 1024*1024 {