bloomchain 0.2.0

Standalone blockchain bloom filter
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

//! Simplifies working with bloom indexes.

use super::Position;

/// Simplifies working with bloom indexes.
pub struct Manager {
	index_size: usize,
	level_sizes: Vec<usize>,
}

impl Manager {
	/// Creates new indexer.
	pub fn new(index_size: usize, levels: usize) -> Self {
		if levels == 0 {
			panic!("Manager requires at least 1 level.");
		}

		let mut level_sizes = vec![1];
		level_sizes.extend_from_slice(&(1..).into_iter()
			.scan(1, |acc, _| {
				*acc = *acc * index_size;
				Some(*acc)
			})
			.take(levels - 1)
			.collect::<Vec<usize>>());

		Manager {
			index_size: index_size,
			level_sizes: level_sizes,
		}
	}

	/// Unsafely get level size.
	pub fn level_size(&self, level: usize) -> usize {
		self.level_sizes[level as usize]
	}

	/// Converts block number and level to `Position`.
	pub fn position(&self, block_number: usize, level: usize) -> Position {
		Position {
			level: level,
			index: block_number / self.level_size(level),
		}
	}

	/// Return bloom which are dependencies for given index.
	///
	/// Bloom indexes are ordered from lowest to highest.
	pub fn lower_level_positions(&self, index: &Position) -> Vec<Position> {
		// this is the lowest level
		if index.level == 0 {
			return vec![];
		}

		let new_level = index.level - 1;
		let offset = self.index_size * index.index;

		(0..self.index_size)
			.map(|i| Position {
				level: new_level, 
				index: offset + i
			})
			.collect()
	}

	/// Return number of levels.
	pub fn levels(&self) -> usize {
		self.level_sizes.len()
	}

	/// Returns max indexer level.
	pub fn max_level(&self) -> usize {
		self.level_sizes.len() - 1
	}
}

#[cfg(test)]
mod tests {
	use position::Position;
	use super::*;
	#[test]
	fn test_level_size() {
		let indexer = Manager::new(16, 3);
		assert_eq!(indexer.level_size(0), 1);
		assert_eq!(indexer.level_size(1), 16);
		assert_eq!(indexer.level_size(2), 256);
	}

	#[test]
	fn test_position() {
		let indexer = Manager::new(16, 3);

		let bi0 = indexer.position(0, 0);
		assert_eq!(bi0.level, 0);
		assert_eq!(bi0.index, 0);

		let bi1 = indexer.position(1, 0);
		assert_eq!(bi1.level, 0);
		assert_eq!(bi1.index, 1);

		let bi2 = indexer.position(2, 0);
		assert_eq!(bi2.level, 0);
		assert_eq!(bi2.index, 2);

		let bi3 = indexer.position(3, 1);
		assert_eq!(bi3.level, 1);
		assert_eq!(bi3.index, 0);

		let bi4 = indexer.position(15, 1);
		assert_eq!(bi4.level, 1);
		assert_eq!(bi4.index, 0);

		let bi5 = indexer.position(16, 1);
		assert_eq!(bi5.level, 1);
		assert_eq!(bi5.index, 1);

		let bi6 = indexer.position(255, 2);
		assert_eq!(bi6.level, 2);
		assert_eq!(bi6.index, 0);

		let bi7 = indexer.position(256, 2);
		assert_eq!(bi7.level, 2);
		assert_eq!(bi7.index, 1);
	}

	#[test]
	fn test_lower_level_positions() {
		let indexer = Manager::new(16, 3);

		let bi = indexer.position(256, 2);
		assert_eq!(bi.level, 2);
		assert_eq!(bi.index, 1);

		let mut ebis = vec![];
		for i in 16..32 {
			ebis.push(Position { level: 1, index: i});
		}

		let bis = indexer.lower_level_positions(&bi);
		assert_eq!(ebis, bis);
	}
}