hypercore 0.3.2

Secure, distributed, append-only log
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

//! Masks used to determine how to update bytes.
//!
//! This piece of code is still a bit unclear; lots of magic numbers. It'd be
//! good to figure out what things mean.

#[derive(Debug)]
pub(super) struct Masks {
  pub index_update: Vec<u8>,
  pub index_iterate: Vec<u8>,
  pub data_iterate: Vec<u8>,
  pub data_update: Vec<u8>,
  pub map_parent_right: Vec<u8>,
  pub map_parent_left: Vec<u8>,
  pub next_data_0_bit: Vec<i16>,
  pub next_index_0_bit: Vec<i16>,
  pub total_1_bits: Vec<u8>,
}

// Masks are underscored at every 8 bytes.
impl Masks {
  pub fn new() -> Self {
    let index_update = vec![
      0b00_11_11_11, //  63
      0b11_00_11_11, // 207
      0b11_11_00_11, // 243
      0b11_11_11_00, // 252
    ];

    let index_iterate = vec![
      0b00_00_00_00, //   0
      0b11_00_00_00, // 192
      0b11_11_00_00, // 240
      0b11_11_11_00, // 252
    ];

    let data_iterate = vec![
      0b10_00_00_00, // 128
      0b11_00_00_00, // 192
      0b11_10_00_00, // 224
      0b11_11_00_00, // 240
      0b11_11_10_00, // 248
      0b11_11_11_00, // 252
      0b11_11_11_10, // 254
      0b11_11_11_11, // 255
    ];

    let data_update = vec![
      0b01_11_11_11, // 127
      0b10_11_11_11, // 191
      0b11_01_11_11, // 223
      0b11_10_11_11, // 223
      0b11_11_01_11, // 247
      0b11_11_10_11, // 251
      0b11_11_11_01, // 253
      0b11_11_11_10, // 254
    ];

    let mut map_parent_right = vec![0; 256];
    let mut map_parent_left = vec![0; 256];

    for i in 0..256 {
      let a = (i & (15 << 4)) >> 4;
      let b = i & 15;

      let left = if a == 15 {
        3
      } else if a == 0 {
        0
      } else {
        1
      };

      let right = if b == 15 {
        3
      } else if b == 0 {
        0
      } else {
        1
      };

      map_parent_right[i] = left | right;
      map_parent_left[i] = map_parent_right[i] << 4;
    }

    let total_1_bits: Vec<_> =
      (0..256).map(|n| (n as u8).count_ones() as u8).collect();

    let mut next_data_0_bit: Vec<_> = (0..256)
      .map(|n| (!n as u8).leading_zeros() as i16)
      .collect();
    next_data_0_bit[255] = -1;

    let mut next_index_0_bit: Vec<_> =
      next_data_0_bit.iter().map(|n| n / 2).collect();
    next_index_0_bit[255] = -1;

    Self {
      index_update,
      index_iterate,
      data_iterate,
      data_update,
      map_parent_right,
      map_parent_left,
      next_data_0_bit,
      next_index_0_bit,
      total_1_bits,
    }
  }
}