use history from utils

core/state-db/Cargo.toml

@@ -9,6 +9,8 @@ parking_lot = "0.9.0"
 log = "0.4"
 primitives = { package = "substrate-primitives", path = "../../core/primitives" }
 codec = { package = "parity-scale-codec", version = "1.0.0", features = ["derive"] }
+historied-data = { path = "../../core/utils/historied-data" }
 
 [dev-dependencies]
 env_logger = "0.6"
+historied-data = { path = "../../core/utils/historied-data", features = ["test"] }

core/state-db/src/branch.rs

@@ -22,8 +22,9 @@ use std::cmp::Reverse;
 use crate::Error;
 use std::hash::Hash as StdHash;
 use std::convert::TryInto;
+use historied_data::tree::{TreeStateTrait, BranchStateTrait, StatesBranchRef, BranchStateRef};
 
-
+#[derive(Clone, Default, Debug)]
 /// Reference to state that is enough for query updates, but not
 /// for gc.
 /// Values are ordered by branch_ix,
@@ -32,20 +33,55 @@ use std::convert::TryInto;
 /// Note that an alternative could be a pointer to a full state
 /// branch for a given branch index, here we use an in memory
 /// copied representation in relation to an actual use case.
-pub type BranchRanges = Vec<StatesBranchRef>;
+pub struct BranchRanges(Vec<StatesBranchRef>);
+
+impl<'a> TreeStateTrait<bool, u64, u64> for &'a BranchRanges {
+	// TODO do we need parent ix field of statesbranchref??
+	type Branch = &'a StatesBranchRef;
+	type Iter = BranchRangesIter<'a>;
+
+	fn get_branch(self, i: u64) -> Option<Self::Branch> {
+		for (b, bi) in self.iter() {
+			if bi == i {
+				return Some(b);
+			} else if bi < i {
+				break;
+			}
+		}
+		None
+	}
+
+	fn last_index(self) -> u64 {
+		let l = self.0.len();
+		if l > 0 {
+			self.0[l - 1].branch_index
+		} else {
+			0
+		}
+	}
 
+	fn iter(self) -> Self::Iter {
+		BranchRangesIter(self, self.0.len())
+	}
 
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct StatesBranchRef {
-	pub branch_index: u64,
-	pub state: LinearStatesRef,
 }
 
-/// This is a simple range, end non inclusive.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct LinearStatesRef {
-	pub start: u64,
-	pub end: u64,
+/// Iterator, contains index of last inner struct.
+pub struct BranchRangesIter<'a>(&'a BranchRanges, usize);
+
+impl<'a> Iterator for BranchRangesIter<'a> {
+	type Item = (&'a StatesBranchRef, u64);
+
+	fn next(&mut self) -> Option<Self::Item> {
+		if self.1 > 0 {
+			Some((
+				&(self.0).0[self.1 - 1],
+				(self.0).0[self.1 - 1].branch_index,
+			))
+		} else {
+			None
+		}
+	}
 }
 
 /// current branches range definition, indexed by branch
@@ -110,14 +146,14 @@ impl RangeSet {
 		// (avoid some intermediatory Vec (eg when building Hashset)
 		let mut result = Vec::new();
 		if branch_index < self.treshold {
-			return result;
+			return BranchRanges(result);
 		}
 		let mut previous_start = u64::max_value();
 		loop {
 			if let Some(Some(StatesBranch{ state, parent_branch_index, .. })) = self.storage.get(&branch_index) {
 				// TODO EMCH consider vecdeque ??
 				let state = if state.end > previous_start {
-					LinearStatesRef {
+					BranchStateRef {
 						start: state.start,
 						end: previous_start,
 					}
@@ -139,7 +175,7 @@ impl RangeSet {
 				break;
 			}
 		}
-		result
+		BranchRanges(result)
 	}
 
 
@@ -235,14 +271,14 @@ impl RangeSet {
 			let anchor_index = self.add_state(parent_branch_index, number)
 				.expect("coherent branch index state"); // TODO EMCH fail in add_state
 			if anchor_index == parent_branch_index {
-				branch_ranges.pop();
+				branch_ranges.0.pop();
 			}
-			branch_ranges.push(self.state_ref(anchor_index).expect("added just above"));
+			branch_ranges.0.push(self.state_ref(anchor_index).expect("added just above"));
 			(branch_ranges, anchor_index)
 		} else {
 			let anchor_index = self.add_state(parent_branch_index, number)
 				.expect("coherent branch index state"); // TODO EMCH fail in add_state
-			(vec![self.state_ref(anchor_index).expect("added just above")], anchor_index)
+			(BranchRanges(vec![self.state_ref(anchor_index).expect("added just above")]), anchor_index)
 		}
 	}
 
@@ -348,7 +384,7 @@ impl RangeSet {
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct StatesBranch {
-	state: LinearStatesRef,
+	state: BranchStateRef,
 	can_append: bool,
 	parent_branch_index: u64,
 }
@@ -369,7 +405,7 @@ impl LinearStates {
 	pub fn new(offset: u64, parent_branch_index: u64) -> Self {
 		let offset = offset as u64;
 		LinearStates {
-			state: LinearStatesRef {
+			state: BranchStateRef {
 				start: offset,
 				end: offset + 1,
 			},
@@ -378,7 +414,7 @@ impl LinearStates {
 		}
 	}
 
-	pub fn state_ref(&self) -> LinearStatesRef {
+	pub fn state_ref(&self) -> BranchStateRef {
 		self.state.clone()
 	}
 
@@ -426,7 +462,7 @@ impl LinearStates {
 }
 
 // TODO EMCH end from historied - data
-//
+#[cfg(test)]
 mod test {
 	use super::*;
 
@@ -457,9 +493,6 @@ mod test {
 
 	#[test]
 	fn branch_range_finalize() {
-		const PREFIX: &[u8] = b"prefix";
-		const TRESHOLD: &[u8] = b"hijkl";
-		const LAST_INDEX: &[u8] = b"mnopq";
 		let with_full_finalize = |
 			full: bool,
 			ranges_valid: &[(u64, u64)],
@@ -492,33 +525,3 @@ mod test {
 
 }
 
-
-// TODO EMCH use from historied data on merge. (this is just a stub)
-
-#[derive(Debug, Clone)]
-pub struct History<V>(Vec<()>, Option<V>);
-
-impl<V> Default for History<V> {
-	fn default() -> Self {
-		History(Vec::new(), None)
-	}
-}
-
-
-impl<V> History<V> {
-
-	pub fn set(&mut self, state: &BranchRanges, value: V) {
-		unimplemented!()
-	}
-
-	pub fn get(&self, state: &BranchRanges) -> Option<&V> {
-		unimplemented!()
-	}
-
-	pub fn gc(&mut self, state: &RangeSet) {
-		unimplemented!()
-	}
-
-}
-
-// End TODO EMCH

core/state-db/src/noncanonical.rs

@@ -25,7 +25,8 @@ use std::collections::{HashMap, VecDeque, hash_map::Entry, HashSet};
 use super::{Error, DBValue, ChangeSet, CommitSet, MetaDb, Hash, to_meta_key, OffstateKey};
 use codec::{Encode, Decode};
 use log::trace;
-use crate::branch::{RangeSet, BranchRanges, History};
+use crate::branch::{RangeSet, BranchRanges};
+use historied_data::tree::History;
 
 const NON_CANONICAL_JOURNAL: &[u8] = b"noncanonical_journal";
 const NON_CANONICAL_OFFSTATE_JOURNAL: &[u8] = b"offstate_noncanonical_journal";

core/utils/historied-data/src/linear.rs

@@ -268,7 +268,6 @@ impl<'a, F: SerializedConfig> Serialized<'a, F> {
 	}
 
 	// Usize encoded as le u64 (only for internal indexing).
-	// TODO EMCH change usize encoding to u32?
 	fn read_le_usize(&self, pos: usize) -> usize {
 		let mut buffer = [0u8; SIZE_BYTE_LEN];
 		buffer.copy_from_slice(&self.0[pos..pos + SIZE_BYTE_LEN]);

core/utils/historied-data/src/tree.rs

@@ -33,6 +33,9 @@ use rstd::vec::Vec;
 use rstd::collections::btree_map::BTreeMap;
 use rstd::convert::{TryFrom, TryInto};
 
+/// Trait defining a state for querying or modifying a tree.
+/// This is therefore the representation of a branch.
+/// TODO EMCH rename to BranchesStateTrait?
 pub trait TreeStateTrait<S, I, BI> {
 	type Branch: BranchStateTrait<S, BI>;
 	type Iter: Iterator<Item = (Self::Branch, I)>;
@@ -46,6 +49,8 @@ pub trait TreeStateTrait<S, I, BI> {
 	fn iter(self) -> Self::Iter;
 }
 
+/// Trait defining a state for querying or modifying a branch.
+/// This is therefore the representation of a branch state.
 pub trait BranchStateTrait<S, I> {
 
 	fn get_node(&self, i: I) -> S;
@@ -54,7 +59,6 @@ pub trait BranchStateTrait<S, I> {
 	fn last_index(&self) -> I;
 }
 
-
 impl<'a> TreeStateTrait<bool, u64, u64> for &'a StatesRef {
 	type Branch = (&'a StatesBranchRef, Option<u64>);
 	type Iter = StatesRefIter<'a>;
@@ -98,7 +102,7 @@ impl<'a> TreeStateTrait<bool, u64, u64> for &'a StatesRef {
 }
 
 #[derive(Debug, Clone)]
-#[cfg_attr(any(test, feature = "test"), derive(PartialEq))]
+#[cfg_attr(any(test, feature = "test"), derive(PartialEq, Eq))]
 pub struct BranchState {
 	/// Index of first element (only use for indexed access).
 	/// Element before offset are not in state.
@@ -113,11 +117,10 @@ pub struct BranchState {
 }
 
 /// This is a simple range, end non inclusive.
-#[derive(Debug, Clone)]
-#[cfg_attr(any(test, feature = "test"), derive(PartialEq))]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub struct BranchStateRef {
-	start: u64,
-	end: u64,
+	pub start: u64,
+	pub end: u64,
 }
 
 impl<'a> BranchStateTrait<bool, u64> for (&'a StatesBranchRef, Option<u64>) {
@@ -136,6 +139,21 @@ impl<'a> BranchStateTrait<bool, u64> for (&'a StatesBranchRef, Option<u64>) {
 
 }
 
+impl<'a> BranchStateTrait<bool, u64> for &'a StatesBranchRef {
+
+	fn get_node(&self, i: u64) -> bool {
+		i >= self.state.start && i < self.state.end
+	}
+
+	fn last_index(&self) -> u64 {
+		// underflow should not happen as long as branchstateref are not allowed to be empty.
+		self.state.end - 1
+	}
+
+}
+
+
+
 impl Default for BranchState {
 	// initialize with one element
 	fn default() -> Self {
@@ -243,7 +261,7 @@ impl Default for TestStates {
 }
 
 #[derive(Debug, Clone)]
-#[cfg_attr(any(test, feature = "test"), derive(PartialEq))]
+#[cfg_attr(any(test, feature = "test"), derive(PartialEq, Eq))]
 pub struct StatesBranch {
 	// this is the key (need to growth unless full gc (can still have
 	// content pointing to it even if it seems safe to reuse a previously
@@ -256,11 +274,10 @@ pub struct StatesBranch {
 	state: BranchState,
 }
 
-#[derive(Debug, Clone)]
-#[cfg_attr(any(test, feature = "test"), derive(PartialEq))]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub struct StatesBranchRef {
-	branch_index: u64,
-	state: BranchStateRef,
+	pub branch_index: u64,
+	pub state: BranchStateRef,
 }
 
 
@@ -336,7 +353,7 @@ impl TestStates {
 					branch_ref.state.end = previous_origin_node_index + 1;
 				}
 				previous_origin_node_index = branch.origin_node_index;
-				// TODO EMCH consider reversing state_ref
+				// vecdeque would be better suited
 				result.insert(0, branch_ref);
 				branch_index = branch.origin_branch_index;
 			} else {
@@ -447,6 +464,7 @@ impl TestStates {
 /// First field is the actual history against which we run
 /// the state.
 /// Second field is an optional value for the no match case.
+/// TODO EMCH consider removing second field (not use out of test)
 #[derive(Debug, Clone)]
 #[cfg_attr(any(test, feature = "test"), derive(PartialEq))]
 pub struct History<V>(Vec<HistoryBranch<V>>, Option<V>);
@@ -564,7 +582,7 @@ impl<V> History<V> {
 			return self.1.as_ref();
 		}
 
-		// TODO EMCH reverse loops ? probably.
+		// TODO EMCH switch loops ? probably.
 		for (state_branch, state_index) in state.iter() {
 			while index > 0 {
 				index -= 1;
@@ -805,7 +823,6 @@ mod test {
 		// cannot create when dropped happen on branch
 		assert_eq!(Some(false), states.branch_state_mut(1).map(|ls| ls.add_state()));
 
-		// TODO add content through branching
 		assert!(states.get(1, 1));
 		// 0> 1: _ _ X
 		// |			 |> 3: 1