1use crate::cesr::cigar::Cigar;
2use crate::cesr::dater::Dater;
3use crate::cesr::diger::Diger;
4use crate::cesr::indexing::siger::Siger;
5use crate::cesr::number::Number;
6use crate::cesr::prefixer::Prefixer;
7use crate::cesr::saider::Saider;
8use crate::cesr::seqner::Seqner;
9use crate::cesr::verfer::Verfer;
10use crate::cesr::{BaseMatter, Parsable};
11use crate::keri::db::dbing::LMDBer;
12use crate::keri::db::subing::cesr::CesrSuberBase;
13use crate::keri::db::subing::{Suber, SuberError};
14use crate::Matter;
15use std::sync::Arc;
16
17pub struct CatCesrSuberBase<M: Matter> {
18 pub base: CesrSuberBase<M>,
19 pub formats: Vec<String>,
20}
21
22impl<M: Matter + Parsable> CatCesrSuberBase<M> {
23 pub fn new(
32 db: Arc<LMDBer>,
33 subkey: &str,
34 formats: Vec<String>,
35 sep: Option<u8>,
36 verify: bool,
37 ) -> Result<Self, SuberError> {
38 let base = CesrSuberBase::new(db, subkey, sep, verify)?;
39
40 Ok(Self { base, formats })
41 }
42
43 pub fn ser(&self, val: &[&dyn Matter]) -> Result<Vec<u8>, SuberError> {
46 match self.formats.as_slice() {
47 [a] if a == "siger" => {
49 if val.len() != 1 {
51 return Err(SuberError::ValueConversionError(
52 "Expected 1 value for siger format".to_string(),
53 ));
54 }
55
56 let siger = match val[0].as_any().downcast_ref::<Siger>() {
57 Some(s) => s,
58 None => {
59 return Err(SuberError::ValueConversionError(
60 "Value must be a Siger".to_string(),
61 ))
62 }
63 };
64
65 self.ser_from_siger(siger)
66 }
67
68 [a, b] if a == "seqner" && b == "saider" => {
70 if val.len() != 2 {
71 return Err(SuberError::ValueConversionError(
72 "Expected 2 values for seqner saider format".to_string(),
73 ));
74 }
75 self.ser_from_seqner_saider(val[0], val[1])
76 }
77
78 [a, b] if a == "verfer" && b == "cigar" => {
80 if val.len() != 2 {
81 return Err(SuberError::ValueConversionError(
82 "Expected 2 values for verfer cigar format".to_string(),
83 ));
84 }
85 self.ser_from_verfer_cigar(val[0], val[1])
86 }
87
88 [a, b] if a == "number" && b == "saider" => {
90 if val.len() != 2 {
91 return Err(SuberError::ValueConversionError(
92 "Expected 2 values for number saider format".to_string(),
93 ));
94 }
95 self.ser_from_number_saider(val[0], val[1])
96 }
97
98 [a, b] if a == "prefixer" && b == "seqner" => {
100 if val.len() != 2 {
101 return Err(SuberError::ValueConversionError(
102 "Expected 2 values for prefixer seqner format".to_string(),
103 ));
104 }
105 self.ser_from_prefixer_seqner(val[0], val[1])
106 }
107
108 [a, b] if a == "seqner" && b == "diger" => {
110 if val.len() != 2 {
111 return Err(SuberError::ValueConversionError(
112 "Expected 2 values for seqner diger format".to_string(),
113 ));
114 }
115 self.ser_from_seqner_diger(val[0], val[1])
116 }
117
118 [a, b, c] if a == "dater" && b == "seqner" && c == "diger" => {
120 if val.len() != 3 {
122 return Err(SuberError::ValueConversionError(
123 "Expected 3 values for dater, seqner, diger format".to_string(),
124 ));
125 }
126
127 self.ser_from_dater_seqner_diger(val[0], val[1], val[2])
128 }
129
130 [a, b, c] if a == "prefixer" && b == "seqner" && c == "saider" => {
132 if val.len() != 3 {
134 return Err(SuberError::ValueConversionError(
135 "Expected 3 values for prefixer, seqner, diger format".to_string(),
136 ));
137 }
138
139 self.ser_from_prefixer_seqner_saider(val[0], val[1], val[2])
140 }
141
142 _ => {
144 Ok(val[0].qb64b())
146 }
147 }
148 }
149
150 pub fn des(&self, val: &[u8]) -> Result<Vec<Box<dyn Matter>>, SuberError> {
153 match self.formats.as_slice() {
154 [a] if a == "siger" => self.des_to_siger(val),
156
157 [a, b] if a == "seqner" && b == "saider" => self.des_to_seqner_saider(val),
159
160 [a, b] if a == "seqner" && b == "diger" => self.des_to_seqner_diger(val),
162
163 [a, b] if a == "verfer" && b == "cigar" => self.des_to_verfer_cigar(val),
165
166 [a, b] if a == "number" && b == "saider" => self.des_to_number_saider(val),
168
169 [a, b] if a == "prefixer" && b == "seqner" => self.des_to_prefixer_seqner(val),
171
172 [a, b, c] if a == "dater" && b == "seqner" && c == "diger" => {
174 self.des_to_dater_seqner_diger(val)
175 }
176
177 [a, b, c] if a == "prefixer" && b == "seqner" && c == "saider" => {
179 self.des_to_prefixer_seqner_saider(val)
180 }
181
182 _ => {
184 let matter = BaseMatter::from_qb64b(&mut val.to_vec(), None)
186 .map_err(|e| SuberError::MatterError(e))?;
187
188 let boxed: Box<dyn Matter> = Box::new(matter);
190 Ok(vec![boxed])
191 }
192 }
193 }
194
195 pub fn ser_from_siger(&self, siger: &Siger) -> Result<Vec<u8>, SuberError> {
197 Ok(siger.qb64b())
198 }
199
200 pub fn des_to_siger(&self, val: &[u8]) -> Result<Vec<Box<dyn Matter>>, SuberError> {
202 let mut data = val.to_vec();
204
205 let siger = Siger::from_qb64b(&mut data, Some(true)).map_err(|e| {
207 SuberError::DeserializationError(format!("Failed to parse Siger: {}", e))
208 })?;
209
210 let result: Vec<Box<dyn Matter>> = vec![Box::new(siger)];
212
213 Ok(result)
214 }
215
216 pub fn ser_from_seqner_saider(
218 &self,
219 seqner: &dyn Matter,
220 saider: &dyn Matter,
221 ) -> Result<Vec<u8>, SuberError> {
222 let mut result = Vec::new();
224 result.extend_from_slice(&seqner.qb64b());
225 result.extend_from_slice(&saider.qb64b());
226
227 Ok(result)
228 }
229
230 pub fn des_to_seqner_saider(&self, val: &[u8]) -> Result<Vec<Box<dyn Matter>>, SuberError> {
232 let mut data = val.to_vec();
234
235 let seqner = Seqner::from_qb64b(&mut data, Some(true)).map_err(|e| {
237 SuberError::DeserializationError(format!("Failed to parse Seqner: {}", e))
238 })?;
239
240 let saider = Saider::from_qb64b(&mut data, Some(true)).map_err(|e| {
242 SuberError::DeserializationError(format!("Failed to parse Saider: {}", e))
243 })?;
244
245 let result: Vec<Box<dyn Matter>> = vec![Box::new(seqner), Box::new(saider)];
246
247 Ok(result)
248 }
249
250 pub fn ser_from_verfer_cigar(
252 &self,
253 verfer: &dyn Matter,
254 cigar: &dyn Matter,
255 ) -> Result<Vec<u8>, SuberError> {
256 let mut result = Vec::new();
258 result.extend_from_slice(&verfer.qb64b());
259 result.extend_from_slice(&cigar.qb64b());
260
261 Ok(result)
262 }
263
264 pub fn des_to_verfer_cigar(&self, val: &[u8]) -> Result<Vec<Box<dyn Matter>>, SuberError> {
266 let mut data = val.to_vec();
268
269 let verfer = Verfer::from_qb64b(&mut data, Some(true)).map_err(|e| {
271 SuberError::DeserializationError(format!("Failed to parse Verfer: {}", e))
272 })?;
273
274 let cigar = Cigar::from_qb64b(&mut data, Some(true)).map_err(|e| {
276 SuberError::DeserializationError(format!("Failed to parse Cigar: {}", e))
277 })?;
278
279 let result: Vec<Box<dyn Matter>> = vec![Box::new(verfer), Box::new(cigar)];
280
281 Ok(result)
282 }
283
284 pub fn ser_from_number_saider(
286 &self,
287 number: &dyn Matter,
288 saider: &dyn Matter,
289 ) -> Result<Vec<u8>, SuberError> {
290 let mut result = Vec::new();
292 result.extend_from_slice(&number.qb64b());
293 result.extend_from_slice(&saider.qb64b());
294
295 Ok(result)
296 }
297
298 pub fn des_to_number_saider(&self, val: &[u8]) -> Result<Vec<Box<dyn Matter>>, SuberError> {
300 let mut data = val.to_vec();
302
303 let number = Number::from_qb64b(&mut data, Some(true)).map_err(|e| {
305 SuberError::DeserializationError(format!("Failed to parse Number: {}", e))
306 })?;
307
308 let saider = Saider::from_qb64b(&mut data, Some(true)).map_err(|e| {
310 SuberError::DeserializationError(format!("Failed to parse Saider: {}", e))
311 })?;
312
313 let result: Vec<Box<dyn Matter>> = vec![Box::new(number), Box::new(saider)];
314
315 Ok(result)
316 }
317
318 pub fn ser_from_prefixer_seqner(
320 &self,
321 prefixer: &dyn Matter,
322 seqner: &dyn Matter,
323 ) -> Result<Vec<u8>, SuberError> {
324 let mut result = Vec::new();
326 result.extend_from_slice(&prefixer.qb64b());
327 result.extend_from_slice(&seqner.qb64b());
328
329 Ok(result)
330 }
331
332 pub fn des_to_prefixer_seqner(&self, val: &[u8]) -> Result<Vec<Box<dyn Matter>>, SuberError> {
334 let mut data = val.to_vec();
336
337 let prefixer = Prefixer::from_qb64b(&mut data, Some(true)).map_err(|e| {
339 SuberError::DeserializationError(format!("Failed to parse Prefixer: {}", e))
340 })?;
341
342 let seqner = Seqner::from_qb64b(&mut data, Some(true)).map_err(|e| {
344 SuberError::DeserializationError(format!("Failed to parse Seqner: {}", e))
345 })?;
346
347 let result: Vec<Box<dyn Matter>> = vec![Box::new(prefixer), Box::new(seqner)];
348
349 Ok(result)
350 }
351
352 pub fn ser_from_seqner_diger(
354 &self,
355 seqner: &dyn Matter,
356 diger: &dyn Matter,
357 ) -> Result<Vec<u8>, SuberError> {
358 let mut result = Vec::new();
360 result.extend_from_slice(&seqner.qb64b());
361 result.extend_from_slice(&diger.qb64b());
362
363 Ok(result)
364 }
365
366 pub fn des_to_seqner_diger(&self, val: &[u8]) -> Result<Vec<Box<dyn Matter>>, SuberError> {
368 let mut data = val.to_vec();
370
371 let seqner = Seqner::from_qb64b(&mut data, Some(true)).map_err(|e| {
373 SuberError::DeserializationError(format!("Failed to parse Seqner: {}", e))
374 })?;
375
376 let diger = Diger::from_qb64b(&mut data, Some(true)).map_err(|e| {
378 SuberError::DeserializationError(format!("Failed to parse Diger: {}", e))
379 })?;
380
381 let result: Vec<Box<dyn Matter>> = vec![Box::new(seqner), Box::new(diger)];
382
383 Ok(result)
384 }
385
386 pub fn ser_from_dater_seqner_diger(
388 &self,
389 dater: &dyn Matter,
390 seqner: &dyn Matter,
391 diger: &dyn Matter,
392 ) -> Result<Vec<u8>, SuberError> {
393 let mut result = Vec::new();
395 result.extend_from_slice(&dater.qb64b());
396 result.extend_from_slice(&seqner.qb64b());
397 result.extend_from_slice(&diger.qb64b());
398
399 Ok(result)
400 }
401
402 pub fn des_to_dater_seqner_diger(
404 &self,
405 val: &[u8],
406 ) -> Result<Vec<Box<dyn Matter>>, SuberError> {
407 let mut data = val.to_vec();
409
410 let dater = Dater::from_qb64b(&mut data, Some(true)).map_err(|e| {
412 SuberError::DeserializationError(format!("Failed to parse Dater: {}", e))
413 })?;
414
415 let seqner = Seqner::from_qb64b(&mut data, Some(true)).map_err(|e| {
417 SuberError::DeserializationError(format!("Failed to parse Seqner: {}", e))
418 })?;
419
420 let diger = Diger::from_qb64b(&mut data, Some(true)).map_err(|e| {
422 SuberError::DeserializationError(format!("Failed to parse Diger: {}", e))
423 })?;
424
425 let result: Vec<Box<dyn Matter>> = vec![Box::new(dater), Box::new(seqner), Box::new(diger)];
426
427 Ok(result)
428 }
429
430 pub fn ser_from_prefixer_seqner_saider(
432 &self,
433 prefixer: &dyn Matter,
434 seqner: &dyn Matter,
435 saider: &dyn Matter,
436 ) -> Result<Vec<u8>, SuberError> {
437 let mut result = Vec::new();
439 result.extend_from_slice(&prefixer.qb64b());
440 result.extend_from_slice(&seqner.qb64b());
441 result.extend_from_slice(&saider.qb64b());
442
443 Ok(result)
444 }
445
446 pub fn des_to_prefixer_seqner_saider(
448 &self,
449 val: &[u8],
450 ) -> Result<Vec<Box<dyn Matter>>, SuberError> {
451 let mut data = val.to_vec();
453
454 let prefixer = Prefixer::from_qb64b(&mut data, Some(true)).map_err(|e| {
456 SuberError::DeserializationError(format!("Failed to parse prefixer: {}", e))
457 })?;
458
459 let seqner = Seqner::from_qb64b(&mut data, Some(true)).map_err(|e| {
461 SuberError::DeserializationError(format!("Failed to parse Seqner: {}", e))
462 })?;
463
464 let saider = Saider::from_qb64b(&mut data, Some(true)).map_err(|e| {
466 SuberError::DeserializationError(format!("Failed to parse saider: {}", e))
467 })?;
468
469 let result: Vec<Box<dyn Matter>> =
470 vec![Box::new(prefixer), Box::new(seqner), Box::new(saider)];
471
472 Ok(result)
473 }
474}
475
476pub struct CatCesrSuber<M: Matter> {
479 pub base: CatCesrSuberBase<M>,
480 pub suber: Suber,
481}
482
483impl<M: Matter + Parsable> CatCesrSuber<M> {
484 pub fn new(
493 db: Arc<LMDBer>,
494 subkey: &str,
495 formats: Vec<String>,
496 sep: Option<u8>,
497 verify: bool,
498 ) -> Result<Self, SuberError> {
499 let base = CatCesrSuberBase::new(db.clone(), subkey, formats, sep, verify)?;
500 let suber = Suber::new(db, subkey, sep, verify)?;
501
502 Ok(Self { base, suber })
503 }
504
505 pub fn put<K: AsRef<[u8]>>(
507 &self,
508 keys: &[K],
509 vals: &[&dyn Matter],
510 ) -> Result<bool, SuberError> {
511 let val_bytes = self.base.ser(vals)?;
513 self.suber.put(keys, &val_bytes)
515 }
516
517 pub fn pin<K: AsRef<[u8]>>(
519 &self,
520 keys: &[K],
521 vals: &[&dyn Matter],
522 ) -> Result<bool, SuberError> {
523 let val_bytes = self.base.ser(vals)?;
525 self.suber.pin(keys, &val_bytes)
527 }
528
529 pub fn get<K: AsRef<[u8]>>(
531 &self,
532 keys: &[K],
533 ) -> Result<Option<Vec<Box<dyn Matter>>>, SuberError> {
534 let val_opt = self.suber.get::<K, Vec<u8>>(keys)?;
536
537 match val_opt {
539 Some(val_bytes) => {
540 let deserialized = self.base.des(&val_bytes)?;
541 Ok(Some(deserialized))
542 }
543 None => Ok(None),
544 }
545 }
546
547 pub fn rem<K: AsRef<[u8]>>(&self, keys: &[K]) -> Result<bool, SuberError> {
549 self.suber.rem(keys)
550 }
551
552 pub fn trim<K: AsRef<[u8]>>(&self, keys: &[K], topive: bool) -> Result<bool, SuberError> {
554 self.suber.trim(keys, topive)
555 }
556
557 pub fn get_full_item_iter<K: AsRef<[u8]>>(
559 &self,
560 keys: &[K],
561 topive: bool,
562 ) -> Result<Vec<(Vec<Vec<u8>>, Vec<u8>)>, SuberError> {
563 self.suber.base.get_full_item_iter(keys, topive)
564 }
565
566 pub fn get_item_iter<K: AsRef<[u8]>>(
568 &self,
569 keys: &[K],
570 topive: bool,
571 ) -> Result<Vec<(Vec<Vec<u8>>, Vec<u8>)>, SuberError> {
572 self.suber.base.get_item_iter(keys, topive)
573 }
574
575 pub fn process_items(
577 &self,
578 items: Vec<(Vec<Vec<u8>>, Vec<u8>)>,
579 ) -> Result<Vec<(Vec<Vec<u8>>, Vec<Box<dyn Matter>>)>, SuberError> {
580 let mut result = Vec::new();
581
582 for (keys, val) in items {
583 let deserialized = self.base.des(&val)?;
584 result.push((keys, deserialized));
585 }
586
587 Ok(result)
588 }
589 pub fn to_key<K: AsRef<[u8]>>(&self, keys: &[K], topive: bool) -> Vec<u8> {
591 self.suber.base.to_key(keys, topive)
592 }
593
594 pub fn to_keys(&self, key: &[u8]) -> Vec<Vec<u8>> {
596 self.suber.base.to_keys(key)
597 }
598
599 pub fn cnt_all(&self) -> Result<usize, SuberError> {
601 self.suber.cnt_all()
602 }
603}
604
605#[cfg(test)]
606mod tests {
607 use crate::cesr::dater::Dater;
608 use crate::cesr::diger::Diger;
609 use crate::cesr::indexing::siger::Siger;
610 use crate::cesr::prefixer::Prefixer;
611 use crate::cesr::saider::Saider;
612 use crate::cesr::seqner::Seqner;
613 use crate::cesr::{BaseMatter, Matter, Parsable};
614 use crate::keri::db::dbing::LMDBerBuilder;
615 use crate::keri::db::subing::catcesr::CatCesrSuber;
616 use crate::keri::db::subing::SuberError;
617
618 use std::sync::Arc;
619
620 #[test]
621 fn test_cat_cesr_suber() -> Result<(), SuberError> {
622 let db = LMDBerBuilder::default()
624 .name("test")
625 .temp(true)
626 .build()
627 .unwrap();
628
629 assert_eq!(db.name(), "test");
630 assert!(db.opened());
631
632 let db_ref = Arc::new(db);
633
634 {
635 let db_ref = db_ref.clone();
637 let sdb = CatCesrSuber::<BaseMatter>::new(
638 db_ref.clone(),
639 "ssdb.",
640 vec!["seqner".to_string(), "saider".to_string()],
641 None,
642 false,
643 )?;
644
645 let seqner = Seqner::from_sn(42);
647 let seqb = seqner.qb64b();
648 assert_eq!(seqb, b"0AAAAAAAAAAAAAAAAAAAAAAq");
649
650 let saider = Saider::from_qb64("EAWY-bDoF3C0LXQBcMNKNnZJNyjRFwzPF6QUQPfBRT7x").unwrap();
651 let saidb = saider.qb64b();
652
653 let vals: Vec<&dyn Matter> = vec![&seqner, &saider];
655
656 let valb = sdb.base.ser(&vals)?;
658 assert_eq!(valb, [&seqb[..], &saidb[..]].concat());
659
660 let des_result = sdb.base.des(&valb)?;
662 let des_values = des_result;
663
664 assert_eq!(des_values.len(), 2);
666
667 let des_seqner = des_values[0].as_any().downcast_ref::<Seqner>().unwrap();
668 let des_saider = des_values[1].as_any().downcast_ref::<Saider>().unwrap();
669
670 assert_eq!(des_seqner.qb64b(), seqner.qb64b());
671 assert_eq!(des_saider.qb64b(), saider.qb64b());
672
673 let combined = [&des_seqner.qb64b()[..], &des_saider.qb64b()[..]].concat();
675 assert_eq!(combined, valb);
676
677 let keys = ["witness", "receipt"];
679
680 assert!(sdb.put(&keys, &vals)?);
682 let actuals = sdb.get(&keys)?;
683 assert!(actuals.is_some());
684
685 let actuals = actuals.unwrap();
686 assert_eq!(actuals.len(), 2);
687
688 let retrieved_seqner = actuals[0].as_any().downcast_ref::<Seqner>().unwrap();
689 let retrieved_saider = actuals[1].as_any().downcast_ref::<Saider>().unwrap();
690
691 assert_eq!(retrieved_seqner.qb64b(), seqner.qb64b());
692 assert_eq!(retrieved_saider.qb64b(), saider.qb64b());
693
694 assert!(sdb.rem(&keys)?);
696 let actuals = sdb.get(&keys)?;
697 assert!(actuals.is_none());
698 }
699
700 {
701 let db_ref = db_ref.clone();
703 let sdb = CatCesrSuber::<BaseMatter>::new(
704 db_ref.clone(),
705 "pssdb.",
706 vec![
707 "prefixer".to_string(),
708 "seqner".to_string(),
709 "saider".to_string(),
710 ],
711 None,
712 false,
713 )?;
714
715 let prefixer =
717 Prefixer::from_qb64("BDzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhcc").unwrap();
718 let preb = prefixer.qb64b();
719
720 let seqner = Seqner::from_sn(99);
721 let seqb = seqner.qb64b();
722 assert_eq!(seqb, b"0AAAAAAAAAAAAAAAAAAAAABj");
723
724 let saider = Saider::from_qb64("EAWY-bDoF3C0LXQBcMNKNnZJNyjRFwzPF6QUQPfBRT7x").unwrap();
725 let saidb = saider.qb64b();
726
727 let vals: Vec<&dyn Matter> = vec![&prefixer, &seqner, &saider];
729
730 let valb = sdb.base.ser(&vals)?;
732 assert_eq!(valb, [&preb[..], &seqb[..], &saidb[..]].concat());
733
734 let des_result = sdb.base.des(&valb)?;
736 let des_values = des_result;
737
738 assert_eq!(des_values.len(), 3);
740
741 let des_prefixer = des_values[0].as_any().downcast_ref::<Prefixer>().unwrap();
742 let des_seqner = des_values[1].as_any().downcast_ref::<Seqner>().unwrap();
743 let des_saider = des_values[2].as_any().downcast_ref::<Saider>().unwrap();
744
745 assert_eq!(des_prefixer.qb64b(), prefixer.qb64b());
746 assert_eq!(des_seqner.qb64b(), seqner.qb64b());
747 assert_eq!(des_saider.qb64b(), saider.qb64b());
748
749 let combined = [
751 &des_prefixer.qb64b()[..],
752 &des_seqner.qb64b()[..],
753 &des_saider.qb64b()[..],
754 ]
755 .concat();
756 assert_eq!(combined, valb);
757
758 let keys = ["delegate", "anchor"];
760
761 assert!(sdb.put(&keys, &vals)?);
763 let actuals = sdb.get(&keys)?;
764 assert!(actuals.is_some());
765
766 let actuals = actuals.unwrap();
767 assert_eq!(actuals.len(), 3);
768
769 let retrieved_prefixer = actuals[0].as_any().downcast_ref::<Prefixer>().unwrap();
770 let retrieved_seqner = actuals[1].as_any().downcast_ref::<Seqner>().unwrap();
771 let retrieved_saider = actuals[2].as_any().downcast_ref::<Saider>().unwrap();
772
773 assert_eq!(retrieved_prefixer.qb64b(), prefixer.qb64b());
774 assert_eq!(retrieved_seqner.qb64b(), seqner.qb64b());
775 assert_eq!(retrieved_saider.qb64b(), saider.qb64b());
776
777 let new_prefixer =
779 Prefixer::from_qb64("BHHzqZWzwE-Wk7K0gzQPYGGwTmuupUhPx5_y1x4ejhcc").unwrap();
780 let new_seqner = Seqner::from_sn(100);
781 let new_saider =
782 Saider::from_qb64("EBJPik4FxfCl-FFsSyGhHpO1VdRQTqIFr11JrYJBSBVk").unwrap();
783
784 let new_vals: Vec<&dyn Matter> = vec![&new_prefixer, &new_seqner, &new_saider];
785
786 assert!(sdb.pin(&keys, &new_vals)?);
788
789 let actuals = sdb.get(&keys)?.unwrap();
790 assert_eq!(actuals.len(), 3);
791
792 let retrieved_prefixer = actuals[0].as_any().downcast_ref::<Prefixer>().unwrap();
793 let retrieved_seqner = actuals[1].as_any().downcast_ref::<Seqner>().unwrap();
794 let retrieved_saider = actuals[2].as_any().downcast_ref::<Saider>().unwrap();
795
796 assert_eq!(retrieved_prefixer.qb64b(), new_prefixer.qb64b());
797 assert_eq!(retrieved_seqner.qb64b(), new_seqner.qb64b());
798 assert_eq!(retrieved_saider.qb64b(), new_saider.qb64b());
799
800 assert!(sdb.rem(&keys)?);
802 let actuals = sdb.get(&keys)?;
803 assert!(actuals.is_none());
804 }
805
806 {
807 let db_ref = db_ref.clone();
809 let sdb = CatCesrSuber::<BaseMatter>::new(
810 db_ref.clone(),
811 "bags.",
812 vec![], Some(b'.'),
814 false,
815 )?;
816
817 let matb0 = "BDzwEHHzq7K0gzQPYGGwTmuupUhPx5_yZ-Wk1x4ejhcc";
819 let matter0 = BaseMatter::from_qb64(matb0).unwrap();
820 let vals0: Vec<&dyn Matter> = vec![&matter0];
821
822 let matb1 = "BHHzqZWzwE-Wk7K0gzQPYGGwTmuupUhPx5_y1x4ejhcc";
823 let matter1 = BaseMatter::from_qb64(matb1).unwrap();
824 let vals1: Vec<&dyn Matter> = vec![&matter1];
825
826 let keys0 = ["alpha", "dog"];
828
829 assert!(sdb.put(&keys0, &vals0)?);
831 let actuals = sdb.get(&keys0)?;
832 assert!(actuals.is_some());
833
834 let actuals = actuals.unwrap();
835 assert_eq!(actuals.len(), 1);
836
837 let retrieved = actuals[0].as_any().downcast_ref::<BaseMatter>().unwrap();
839 assert_eq!(retrieved.qb64(), matter0.qb64());
840
841 assert!(sdb.rem(&keys0)?);
843 let actuals = sdb.get(&keys0)?;
844 assert!(actuals.is_none());
845
846 assert!(sdb.put(&keys0, &vals0)?);
848 let actuals = sdb.get(&keys0)?.unwrap();
849 assert_eq!(actuals.len(), 1);
850 let retrieved = actuals[0].as_any().downcast_ref::<BaseMatter>().unwrap();
851 assert_eq!(retrieved.qb64(), matter0.qb64());
852
853 let result = sdb.put(&keys0, &vals1)?;
855 assert!(!result);
856
857 assert!(sdb.pin(&keys0, &vals1)?);
859 let actuals = sdb.get(&keys0)?.unwrap();
860 assert_eq!(actuals.len(), 1);
861 let retrieved = actuals[0].as_any().downcast_ref::<BaseMatter>().unwrap();
862 assert_eq!(retrieved.qb64(), matter1.qb64());
863
864 assert!(sdb.rem(&keys0)?);
866 let actuals = sdb.get(&keys0)?;
867 assert!(actuals.is_none());
868
869 let keys1 = ["beta.fish"];
871 assert!(sdb.put(&keys1, &vals1)?);
872 let actuals = sdb.get(&keys1)?.unwrap();
873 assert_eq!(actuals.len(), 1);
874 let retrieved = actuals[0].as_any().downcast_ref::<BaseMatter>().unwrap();
875 assert_eq!(retrieved.qb64(), matter1.qb64());
876
877 assert!(sdb.rem(&keys1)?);
879 let actuals = sdb.get(&keys1)?;
880 assert!(actuals.is_none());
881
882 let badkey = ["badkey"];
884 let actuals = sdb.get(&badkey)?;
885 assert!(actuals.is_none());
886 assert!(sdb.put(&keys0, &vals0)?);
888 assert!(sdb.put(&keys1, &vals1)?);
889
890 let prefix_key: [&str; 0] = [];
891
892 let raw_items = sdb.get_item_iter(&prefix_key, true)?;
893
894 let items: Vec<(Vec<String>, String)> = raw_items
896 .iter()
897 .map(|(keys, vals)| {
898 let key_strs = keys
900 .iter()
901 .map(|k| String::from_utf8(k.clone()).unwrap())
902 .collect();
903
904 let matter = BaseMatter::from_qb64b(&mut vals.clone(), None).unwrap();
906 let qb64 = matter.qb64();
907
908 (key_strs, qb64)
909 })
910 .collect();
911
912 let mut found_item1 = false;
915 let mut found_item2 = false;
916
917 for (key_parts, val) in items {
918 if (key_parts[0] == "alpha" && key_parts[1] == "dog" && val == matter0.qb64())
919 || (key_parts.len() == 1
920 && key_parts[0] == "alpha.dog"
921 && val == matter0.qb64())
922 {
923 found_item1 = true;
924 }
925 if (key_parts[0] == "beta" && key_parts[1] == "fish" && val == matter1.qb64())
926 || (key_parts.len() == 1
927 && key_parts[0] == "beta.fish"
928 && val == matter1.qb64())
929 {
930 found_item2 = true;
931 }
932 }
933
934 assert!(found_item1);
935 assert!(found_item2);
936
937 assert!(sdb.put(&["b", "1"], &vals0)?);
939 assert!(sdb.put(&["b", "2"], &vals1)?);
940 assert!(sdb.put(&["c", "1"], &vals0)?);
941 assert!(sdb.put(&["c", "2"], &vals1)?);
942
943 let topkeys = ["b", ""];
944 let raw_items = sdb.get_item_iter(&topkeys, true)?;
945
946 let items: Vec<(Vec<String>, String)> = raw_items
948 .iter()
949 .map(|(keys, vals)| {
950 let key_strs = keys
951 .iter()
952 .map(|k| String::from_utf8(k.clone()).unwrap())
953 .collect();
954
955 let matter = BaseMatter::from_qb64b(&mut vals.clone(), None).unwrap();
956 let qb64 = matter.qb64();
957
958 (key_strs, qb64)
959 })
960 .collect();
961
962 assert_eq!(items.len(), 2);
964
965 let mut found_b1 = false;
966 let mut found_b2 = false;
967
968 for (key_parts, val) in items {
969 if (key_parts[0] == "b" && key_parts[1] == "1" && val == matter0.qb64()) {
970 found_b1 = true;
971 }
972 if (key_parts[0] == "b" && key_parts[1] == "2" && val == matter1.qb64()) {
973 found_b2 = true;
974 }
975 }
976
977 assert!(found_b1);
978 assert!(found_b2);
979 }
980
981 {
982 let db_ref = db_ref.clone();
984 let sdb = CatCesrSuber::<BaseMatter>::new(
985 db_ref.clone(),
986 "bags.",
987 vec![
988 "dater".to_string(),
989 "seqner".to_string(),
990 "diger".to_string(),
991 ],
992 None,
993 false,
994 )?;
995
996 let dater = Dater::from_dt(chrono::Utc::now());
998 let datb = dater.qb64b();
999
1000 let seqner = Seqner::from_sn(20);
1001 let seqb = seqner.qb64b();
1002 assert_eq!(seqb, b"0AAAAAAAAAAAAAAAAAAAAAAU");
1003
1004 let diger = Diger::from_ser("Hello Me Maties.".as_bytes(), None)?;
1005 let digb = diger.qb64b();
1006
1007 let vals: Vec<&dyn Matter> = vec![&dater, &seqner, &diger];
1009
1010 let valb = sdb.base.ser(&vals)?;
1012 assert_eq!(valb, [&datb[..], &seqb[..], &digb[..]].concat());
1013
1014 let des_result = sdb.base.des(&valb)?;
1016 let des_values = des_result;
1017
1018 assert_eq!(des_values.len(), 3);
1020
1021 let des_dater = des_values[0].as_any().downcast_ref::<Dater>().unwrap();
1022 let des_seqner = des_values[1].as_any().downcast_ref::<Seqner>().unwrap();
1023 let des_diger = des_values[2].as_any().downcast_ref::<Diger>().unwrap();
1024
1025 assert_eq!(des_dater.qb64b(), dater.qb64b());
1026 assert_eq!(des_seqner.qb64b(), seqner.qb64b());
1027 assert_eq!(des_diger.qb64b(), diger.qb64b());
1028
1029 let combined = [
1031 &des_dater.qb64b()[..],
1032 &des_seqner.qb64b()[..],
1033 &des_diger.qb64b()[..],
1034 ]
1035 .concat();
1036 assert_eq!(combined, valb);
1037 }
1038
1039 {
1040 let db_ref = db_ref.clone();
1042 let sdb = CatCesrSuber::<BaseMatter>::new(
1043 db_ref.clone(),
1044 "pigs.",
1045 vec!["siger".to_string()],
1046 None,
1047 false,
1048 )?;
1049
1050 let sig0 = "AACdI8OSQkMJ9r-xigjEByEjIua7LHH3AOJ22PQKqljMhuhcgh9nGRcKnsz5KvKd7K_H9-1298F4Id1DxvIoEmCQ";
1052 let val0 = Siger::from_qb64(sig0, None).unwrap();
1053
1054 let keys = ["zeta", "cat"];
1056 assert!(sdb.put(&keys, &[&val0])?);
1057
1058 let actuals = sdb.get(&keys)?.unwrap();
1059 assert_eq!(actuals.len(), 1);
1060
1061 let actual_siger = actuals[0].as_any().downcast_ref::<Siger>().unwrap();
1062 assert_eq!(actual_siger.qb64(), val0.qb64());
1063 }
1064
1065 Ok(())
1066 }
1067}