1use crate::cesr::Matter;
2use crate::cesr::Parsable;
3use crate::keri::db::dbing::LMDBer;
4use crate::keri::db::subing::cesr::CesrSuberBase;
5use crate::keri::db::subing::ioset::IoSetSuber;
6use crate::keri::db::subing::SuberError;
7use std::sync::Arc;
8
9pub struct CesrIoSetSuber<M: Matter> {
10 pub base: CesrSuberBase<M>,
11 pub io_set_suber: IoSetSuber<crate::keri::db::subing::cesr::CesrCodec<M>>,
12}
13
14impl<M: Matter + Parsable> CesrIoSetSuber<M> {
15 pub fn new(
16 db: Arc<LMDBer>,
17 subkey: &str,
18 sep: Option<u8>,
19 verify: bool,
20 ) -> Result<Self, SuberError> {
21 let base = CesrSuberBase::new(db.clone(), subkey, sep, verify)?;
22 let io_set_suber = IoSetSuber::new(db, subkey, sep, verify)?;
23
24 Ok(Self { base, io_set_suber })
25 }
26
27 pub fn _ser(&self, val: &M) -> Result<Vec<u8>, SuberError> {
29 self.base.ser(val)
30 }
31
32 pub fn _des(&self, val: &[u8]) -> Result<M, SuberError> {
33 self.base.des(val)
34 }
35
36 pub fn put<K: AsRef<[u8]>>(&self, keys: &[K], vals: &[&M]) -> Result<bool, SuberError> {
38 let ser_vals: Vec<Vec<u8>> = vals
40 .iter()
41 .map(|val| self._ser(val))
42 .collect::<Result<Vec<Vec<u8>>, SuberError>>()?;
43
44 let ser_vals_refs: Vec<&Vec<u8>> = ser_vals.iter().collect();
45
46 self.io_set_suber.put(keys, &ser_vals_refs)
47 }
48
49 pub fn add<K: AsRef<[u8]>>(&self, keys: &[K], val: &M) -> Result<bool, SuberError> {
50 let ser_val = self._ser(val)?;
51 self.io_set_suber.add(keys, &ser_val)
52 }
53
54 pub fn pin<K: AsRef<[u8]>>(&self, keys: &[K], vals: &[&M]) -> Result<bool, SuberError> {
55 let ser_vals: Vec<Vec<u8>> = vals
57 .iter()
58 .map(|val| self._ser(val))
59 .collect::<Result<Vec<Vec<u8>>, SuberError>>()?;
60
61 let ser_vals_refs: Vec<&Vec<u8>> = ser_vals.iter().collect();
62
63 self.io_set_suber.pin(keys, &ser_vals_refs)
64 }
65
66 pub fn get<K: AsRef<[u8]>>(&self, keys: &[K]) -> Result<Vec<M>, SuberError> {
67 let ser_vals = self.io_set_suber.get::<K, Vec<u8>>(keys)?;
68 let matters: Result<Vec<M>, SuberError> =
69 ser_vals.into_iter().map(|val| self._des(&val)).collect();
70 matters
71 }
72
73 pub fn get_iter<K: AsRef<[u8]>>(&self, keys: &[K]) -> Result<Vec<M>, SuberError> {
74 let values = self.io_set_suber.get::<K, Vec<u8>>(keys)?;
75 values.into_iter().map(|val| self._des(&val)).collect()
76 }
77
78 pub fn get_last<K: AsRef<[u8]>>(&self, keys: &[K]) -> Result<Option<M>, SuberError> {
79 if let Some(ser_val) = self.io_set_suber.get_last::<K, Vec<u8>>(keys)? {
80 Ok(Some(self._des(&ser_val)?))
81 } else {
82 Ok(None)
83 }
84 }
85
86 pub fn rem<K: AsRef<[u8]>>(&self, keys: &[K], val: Option<&M>) -> Result<bool, SuberError> {
87 match val {
88 Some(m) => {
89 let ser_val = self._ser(m)?;
90 self.io_set_suber.rem::<K, Vec<u8>>(keys, Some(&ser_val))
91 }
92 None => self.io_set_suber.rem::<K, Vec<u8>>(keys, None),
93 }
94 }
95
96 pub fn cnt<K: AsRef<[u8]>>(&self, keys: &[K]) -> Result<usize, SuberError> {
97 self.io_set_suber.cnt(keys)
98 }
99
100 pub fn get_item_iter<K: AsRef<[u8]>>(
102 &self,
103 keys: &[K],
104 topive: bool,
105 ) -> Result<Vec<(Vec<Vec<u8>>, M)>, SuberError> {
106 let items = self.io_set_suber.get_full_item_iter(keys, topive)?;
107 items
108 .into_iter()
109 .map(|(keys_vec, val)| Ok((keys_vec, self._des(&val)?)))
110 .collect()
111 }
112
113 pub fn to_key<K: AsRef<[u8]>>(&self, keys: &[K], topive: bool) -> Vec<u8> {
115 self.io_set_suber.base.to_key(keys, topive)
116 }
117
118 pub fn to_keys(&self, key: &[u8]) -> Vec<Vec<u8>> {
119 self.io_set_suber.base.to_keys(key)
120 }
121
122 pub fn trim<K: AsRef<[u8]>>(&self, keys: &[K], topive: bool) -> Result<bool, SuberError> {
123 self.io_set_suber.trim(keys, topive)
124 }
125
126 pub fn get_full_item_iter<K: AsRef<[u8]>>(
127 &self,
128 keys: &[K],
129 topive: bool,
130 ) -> Result<Vec<(Vec<Vec<u8>>, Vec<u8>)>, SuberError> {
131 self.io_set_suber.get_full_item_iter(keys, topive)
132 }
133
134 pub fn cnt_all(&self) -> Result<usize, SuberError> {
135 self.io_set_suber.base.cnt_all()
136 }
137 pub fn is_dupsort(&self) -> bool {
142 self.base.base.is_dupsort()
143 }
144}
145
146#[cfg(test)]
147mod tests {
148 use crate::cesr::diger::Diger;
149 use crate::cesr::saider::Saider;
150 use crate::cesr::seqner::Seqner;
151 use crate::cesr::Matter;
152 use crate::keri::core::serdering::{sad::SadValue, Sadder};
153 use crate::keri::db::dbing::{LMDBer, LMDBerBuilder};
154 use crate::keri::db::subing::cesrioset::CesrIoSetSuber;
155 use crate::keri::db::subing::SuberError;
156 use indexmap::IndexMap;
157 use serde_json::{json, Value};
158 use std::sync::Arc;
159
160 #[test]
161 fn test_cesr_ioset_suber() -> Result<(), SuberError> {
162 let db = LMDBerBuilder::default().name("test").temp(true).build()?;
164
165 assert_eq!(db.name(), "test");
166 assert!(db.opened());
167
168 {
169 let db_ref = Arc::new(db);
171 let cisuber = CesrIoSetSuber::<Saider>::new(db_ref, "bags.", None, false)?;
172 assert!(!cisuber.is_dupsort());
173
174 let seqner0 = Seqner::from_sn(20);
176 let seq0 = seqner0.qb64();
177 assert_eq!(seq0, "0AAAAAAAAAAAAAAAAAAAAAAU");
178
179 let seqner1 = Seqner::from_sn(10);
180 let seq1 = seqner1.qb64();
181 assert_eq!(seq1, "0AAAAAAAAAAAAAAAAAAAAAAK");
182
183 let diger0 = Diger::from_ser("Hello Me Maties.".as_bytes(), None)?;
185 let dig0 = diger0.qb64();
186 assert_eq!(dig0, "ELq6uSA62FaWKAQf2rclt4D1wRAeVwQ7hBucDG43GrsJ");
187
188 let diger1 = Diger::from_ser("Bye Y'all.".as_bytes(), None)?;
189 let dig1 = diger1.qb64();
190 assert_eq!(dig1, "EK--ZWfMjPZ8R90eDBuwy9umo1CnxpF95H550OGv65ry");
191
192 let keys0 = [seq0.as_str(), dig0.as_str()];
194 let keys1 = [seq1.as_str(), dig1.as_str()];
195
196 let mut sad0: Sadder = IndexMap::new();
198 sad0.insert("v".to_string(), SadValue::from_string("KERI10JSON000000_"));
199 sad0.insert("t".to_string(), SadValue::from_string("rpy"));
200 sad0.insert("d".to_string(), SadValue::from_string("")); sad0.insert(
202 "dt".to_string(),
203 SadValue::from_string("2020-08-22T17:50:12.988921+00:00"),
204 );
205 sad0.insert("r".to_string(), SadValue::from_string("/help/me"));
206
207 let mut a_dict: IndexMap<String, SadValue> = IndexMap::new();
209 a_dict.insert("name".to_string(), SadValue::from_string("John Jones"));
210 a_dict.insert("role".to_string(), SadValue::from_string("Founder"));
211 sad0.insert("a".to_string(), SadValue::Object(a_dict));
212
213 let (saider0, sadified0) = Saider::saidify(sad0, None, None, None, None)
215 .map_err(|e| SuberError::ValueConversionError(e.to_string()))?;
216 let said0 = saider0.qb64().to_string();
217 assert_eq!(said0, "EKwVGsUU1sUlYRq_g2Z3_3GOIREYtlQ3kPSNjpg8w4j0");
218
219 let mut sad1: Sadder = IndexMap::new();
221 sad1.insert("v".to_string(), SadValue::from_string("KERI10JSON000000_"));
222 sad1.insert("t".to_string(), SadValue::from_string("rpy"));
223 sad1.insert("d".to_string(), SadValue::from_string("")); sad1.insert(
225 "dt".to_string(),
226 SadValue::from_string("2020-08-22T17:50:12.988921+00:00"),
227 );
228 sad1.insert("r".to_string(), SadValue::from_string("/help/you"));
229
230 let mut a_dict: IndexMap<String, SadValue> = IndexMap::new();
232 a_dict.insert("name".to_string(), SadValue::from_string("Sue Swan"));
233 a_dict.insert("role".to_string(), SadValue::from_string("Creator"));
234 sad1.insert("a".to_string(), SadValue::Object(a_dict));
235
236 let (saider1, sadified1) = Saider::saidify(sad1, None, None, None, None)
237 .map_err(|e| SuberError::ValueConversionError(e.to_string()))?;
238 let said1 = saider1.qb64().to_string();
239 assert_eq!(said1, "EPl1dMAs2RDsZ12K3yxA0fTHP6dRJzDkStf65VVeFxne");
240
241 let mut sad2: Sadder = IndexMap::new();
243 sad2.insert("v".to_string(), SadValue::from_string("KERI10JSON000000_"));
244 sad2.insert("t".to_string(), SadValue::from_string("rpy"));
245 sad2.insert("d".to_string(), SadValue::from_string("")); sad2.insert(
247 "dt".to_string(),
248 SadValue::from_string("2020-08-22T17:50:30.988921+00:00"),
249 );
250 sad2.insert("r".to_string(), SadValue::from_string("/find/out"));
251
252 let mut a_dict: IndexMap<String, SadValue> = IndexMap::new();
254 a_dict.insert("name".to_string(), SadValue::from_string("Zoe Zigler"));
255 a_dict.insert("role".to_string(), SadValue::from_string("Maven"));
256 sad2.insert("a".to_string(), SadValue::Object(a_dict));
257
258 let (saider2, sadified2) = Saider::saidify(sad2, None, None, None, None)
259 .map_err(|e| SuberError::ValueConversionError(e.to_string()))?;
260 let said2 = saider2.qb64().to_string();
261 assert_eq!(said2, "EJxOaEsBSObrcmrsnlfHOdVAowGhUBKoE2Ce3TZ4Mhgu");
262
263 assert!(cisuber.put(&keys0, &[&saider1, &saider0])?);
265 assert_eq!(cisuber.cnt(&keys0)?, 2);
266
267 let actuals = cisuber.get(&keys0)?;
268 assert_eq!(actuals.len(), 2);
269 let sers: Vec<String> = actuals.iter().map(|actual| actual.qb64()).collect();
270 assert_eq!(sers, vec![said1.clone(), said0.clone()]);
271
272 if let Some(actual) = cisuber.get_last(&keys0)? {
273 assert_eq!(actual.qb64(), said0);
274 } else {
275 panic!("Expected a value from get_last but got None");
276 }
277
278 assert!(cisuber.rem(&keys0, None)?);
280 let actuals = cisuber.get(&keys0)?;
281 assert!(actuals.is_empty());
282 assert_eq!(cisuber.cnt(&keys0)?, 0);
283
284 assert!(cisuber.put(&keys0, &[&saider0, &saider1])?);
286 assert_eq!(cisuber.cnt(&keys0)?, 2);
287
288 let actuals = cisuber.get(&keys0)?;
289 assert_eq!(actuals.len(), 2);
290 let sers: Vec<String> = actuals.iter().map(|actual| actual.qb64()).collect();
291 assert_eq!(sers, vec![said0.clone(), said1.clone()]);
292
293 if let Some(actual) = cisuber.get_last(&keys0)? {
294 assert_eq!(actual.qb64(), said1);
295 } else {
296 panic!("Expected a value from get_last but got None");
297 }
298
299 assert!(cisuber.add(&keys0, &saider2)?);
301 assert_eq!(cisuber.cnt(&keys0)?, 3);
302
303 let actuals = cisuber.get(&keys0)?;
304 assert_eq!(actuals.len(), 3);
305 let sers: Vec<String> = actuals.iter().map(|actual| actual.qb64()).collect();
306 assert_eq!(sers, vec![said0.clone(), said1.clone(), said2.clone()]);
307
308 if let Some(actual) = cisuber.get_last(&keys0)? {
309 assert_eq!(actual.qb64(), said2);
310 } else {
311 panic!("Expected a value from get_last but got None");
312 }
313
314 assert!(cisuber.pin(&keys0, &[&saider1, &saider2])?);
316 assert_eq!(cisuber.cnt(&keys0)?, 2);
317
318 let actuals = cisuber.get(&keys0)?;
319 assert_eq!(actuals.len(), 2);
320 let sers: Vec<String> = actuals.iter().map(|actual| actual.qb64()).collect();
321 assert_eq!(sers, vec![said1.clone(), said2.clone()]);
322
323 assert!(cisuber.put(&keys1, &[&saider2, &saider1, &saider0])?);
325 assert_eq!(cisuber.cnt(&keys1)?, 3);
326
327 let actuals = cisuber.get(&keys1)?;
328 assert_eq!(actuals.len(), 3);
329 let sers: Vec<String> = actuals.iter().map(|actual| actual.qb64()).collect();
330 assert_eq!(sers, vec![said2.clone(), said1.clone(), said0.clone()]);
331
332 assert!(cisuber.rem(&keys1, Some(&saider1))?);
334 assert_eq!(cisuber.cnt(&keys1)?, 2);
335
336 let actuals = cisuber.get(&keys1)?;
337 assert_eq!(actuals.len(), 2);
338 let sers: Vec<String> = actuals.iter().map(|actual| actual.qb64()).collect();
339 assert_eq!(sers, vec![said2.clone(), said0.clone()]);
340
341 let actuals = cisuber.get_iter(&keys1)?;
343 let sers: Vec<String> = actuals.iter().map(|actual| actual.qb64()).collect();
344 assert_eq!(sers, vec![said2.clone(), said0.clone()]);
345
346 let items = cisuber.get_item_iter(&[] as &[&str], false)?;
348
349 assert_eq!(items.len(), 4);
351
352 let items_converted: Vec<(Vec<String>, String)> = items
354 .into_iter()
355 .map(|(keys, val)| {
356 (
357 keys.into_iter()
358 .map(|key| String::from_utf8(key).unwrap())
359 .collect(),
360 val.qb64(),
361 )
362 })
363 .collect();
364
365 let full_items = cisuber.get_full_item_iter(&[] as &[&str], false)?;
367 assert_eq!(full_items.len(), 4);
368
369 let full_items_converted: Vec<(Vec<String>, Vec<u8>)> = full_items
371 .into_iter()
372 .map(|(keys, val)| {
373 (
374 keys.into_iter()
375 .map(|key| String::from_utf8(key).unwrap())
376 .collect(),
377 val,
378 )
379 })
380 .collect();
381
382 for (keys, _) in &full_items_converted {
384 assert_eq!(keys.len(), 3, "Full item key should have 3 parts");
385 assert!(
387 keys[2].starts_with("000000000000000000000000000000"),
388 "Third part of key should be ordinal: {}",
389 keys[2]
390 );
391 }
392
393 let items = cisuber.get_item_iter(&keys0, false)?;
395 let items_converted: Vec<(Vec<String>, String)> = items
396 .into_iter()
397 .map(|(keys, val)| {
398 (
399 keys.into_iter()
400 .map(|key| String::from_utf8(key).unwrap())
401 .collect(),
402 val.qb64(),
403 )
404 })
405 .collect();
406
407 assert_eq!(items_converted.len(), 2);
408 assert_eq!(items_converted[0].0[0], seq0);
409 assert_eq!(items_converted[0].0[1], dig0);
410
411 let topkeys = [seq1, String::from("")];
413 let items = cisuber.get_item_iter(&topkeys, false)?;
414 let items_converted: Vec<(Vec<String>, String)> = items
415 .into_iter()
416 .map(|(keys, val)| {
417 (
418 keys.into_iter()
419 .map(|key| String::from_utf8(key).unwrap())
420 .collect(),
421 val.qb64(),
422 )
423 })
424 .collect();
425
426 assert_eq!(items_converted.len(), 2);
427
428 let topkeys = [seq0, String::from("")];
430 let items = cisuber.get_full_item_iter(&topkeys, false)?;
431 let items_converted: Vec<(Vec<String>, Vec<u8>)> = items
432 .into_iter()
433 .map(|(keys, val)| {
434 (
435 keys.into_iter()
436 .map(|key| String::from_utf8(key).unwrap())
437 .collect(),
438 val,
439 )
440 })
441 .collect();
442
443 assert_eq!(items_converted.len(), 2);
444 }
445
446 Ok(())
447 }
448}