cido 0.2.0

Core traits and implementations for indexing with cido
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
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178

use crate::stable_hash::{self, FieldAddress};
use crate::types::*;

/// Used in proof of indexing to add a hash for the type of field that is used
///
/// This may be removed in the future depending on how useful it proves to be
#[repr(u8)]
pub enum ValueVariant {
  String = 1,     // AsString
  Int = 2,        // i32
  BigDecimal = 3, // BigDecimal
  Bool = 4,       // bool
  List = 5,       // Vec<T: ValueVariant != List>
  Bytes = 6,      // AsBytes<T: AsRef<[u8]>>
  BigInt = 7,     // BigInt
  Int8 = 8,       // i64
}

impl From<ValueVariant> for u8 {
  #[inline(always)]
  fn from(value: ValueVariant) -> Self {
    value as u8
  }
}

pub struct ValueTypeHasher<T: Hashable> {
  pub field: &'static str,
  pub data: T,
}

impl<T> stable_hash::StableHash for ValueTypeHasher<T>
where
  T: Hashable,
{
  fn stable_hash<H: stable_hash::StableHasher>(&self, field_address: H::Addr, state: &mut H) {
    self.field.stable_hash(field_address.child(0), state);
    <T as Hashable>::with_new(&self.data, field_address.child(1), state);
  }
}

/// This is the trait actually used in the implementation on entities and events and it hashes the
/// value along with its data type
pub trait Hashable: stable_hash::StableHash {
  fn with_new<H: stable_hash::StableHasher>(&self, field_address: H::Addr, state: &mut H) {
    <Self as stable_hash::StableHash>::stable_hash(self, field_address.child(0), state);
    state.write(field_address, &[Self::variant_numeric()]);
  }

  fn variant() -> ValueVariant;

  #[inline(always)]
  fn variant_numeric() -> u8 {
    Self::variant() as u8
  }
}

impl<'a, T: Hashable> Hashable for &'a T {
  #[inline(always)]
  fn variant() -> ValueVariant {
    <T as Hashable>::variant()
  }
}

impl<T: Hashable> Hashable for Vec<T> {
  #[inline(always)]
  fn variant() -> ValueVariant {
    ValueVariant::List
  }
}

impl<T: Hashable> Hashable for Option<T> {
  #[inline(always)]
  fn variant() -> ValueVariant {
    <T as Hashable>::variant()
  }

  fn with_new<H: stable_hash::StableHasher>(&self, field_address: H::Addr, state: &mut H) {
    if let Some(val) = self {
      <T as Hashable>::with_new(val, field_address, state)
    }
  }
}

/// String like implementations, the stable_hash implementations for this types
/// requires the types to be encoded as strings first.
mod string_like {
  use super::*;

  impl Hashable for String {
    #[inline(always)]
    fn variant() -> ValueVariant {
      ValueVariant::String
    }
  }

  impl<'a> Hashable for &'a str {
    #[inline(always)]
    fn variant() -> ValueVariant {
      <String as Hashable>::variant()
    }
  }
}

// treat it as an i32
impl Hashable for i16 {
  #[inline(always)]
  fn variant() -> ValueVariant {
    ValueVariant::Int
  }
}

impl Hashable for i32 {
  #[inline(always)]
  fn variant() -> ValueVariant {
    ValueVariant::Int
  }
}

impl Hashable for BigDecimal {
  #[inline(always)]
  fn variant() -> ValueVariant {
    ValueVariant::BigDecimal
  }
}

impl Hashable for bool {
  #[inline(always)]
  fn variant() -> ValueVariant {
    ValueVariant::Bool
  }
}

// todo: should be using AsBytes<&Vec<u8>> to hash Vec<u8> preferably
impl Hashable for Vec<u8> {
  #[inline(always)]
  fn variant() -> ValueVariant {
    ValueVariant::Bytes
  }
}

impl Hashable for crate::types::Bytes {
  #[inline(always)]
  fn variant() -> ValueVariant {
    ValueVariant::String
  }
}

impl Hashable for BigInt {
  #[inline(always)]
  fn variant() -> ValueVariant {
    ValueVariant::BigInt
  }
}

impl Hashable for i64 {
  #[inline(always)]
  fn variant() -> ValueVariant {
    ValueVariant::Int8
  }
}

impl<const N: usize> Hashable for H<N> {
  #[inline(always)]
  fn variant() -> ValueVariant {
    ValueVariant::Bytes
  }
}

impl<const N: usize> Hashable for U<N>
where
  U<N>: crate::types::ByteArray,
  <U<N> as crate::types::ByteArray>::Array: AsRef<[u8]>,
{
  #[inline(always)]
  fn variant() -> ValueVariant {
    ValueVariant::Bytes
  }
}