1use crate::keri::db::dbing::LMDBer;
2use crate::keri::db::errors::DBError;
3use crate::keri::db::subing::iodup::IoDupSuber;
4use crate::keri::db::subing::on::OnSuberBase;
5use crate::keri::db::subing::{SuberError, Utf8Codec, ValueCodec};
6use std::sync::Arc;
7
8use std::ops::Bound;
9
10pub struct OnIoDupSuber<C: ValueCodec = Utf8Codec> {
11 pub on_base: OnSuberBase<C>,
12 pub io_dup_suber: IoDupSuber<C>,
13}
14
15impl<C: ValueCodec> OnIoDupSuber<C> {
16 pub fn new(
17 db: Arc<LMDBer>,
18 subkey: &str,
19 sep: Option<u8>,
20 verify: bool,
21 ) -> Result<Self, SuberError> {
22 let on_base = OnSuberBase::new(db.clone(), subkey, sep, verify, Some(true))?;
23 let io_dup_suber = IoDupSuber::new(db, subkey, sep, verify)?;
24
25 Ok(Self {
26 on_base,
27 io_dup_suber,
28 })
29 }
30
31 pub fn add_on<K: AsRef<[u8]>, V: ?Sized + Clone + Into<Vec<u8>>>(
34 &self,
35 keys: &[K],
36 on: u32,
37 val: &V,
38 ) -> Result<bool, SuberError> {
39 let key = self.on_base._tokey(keys);
40 let sval = self.on_base._ser(val)?;
41
42 self.on_base
43 .base
44 .db
45 .add_on_io_dup_val(
46 &self.on_base.base.sdb,
47 &key,
48 Some(on as u64),
49 &sval,
50 Some([self.on_base.base.sep]),
51 )
52 .map_err(SuberError::DBError)
53 }
54
55 pub fn append_on<K: AsRef<[u8]>, V: ?Sized + Clone + Into<Vec<u8>>>(
57 &self,
58 keys: &[K],
59 val: &V,
60 ) -> Result<u64, SuberError> {
61 let key = self.on_base._tokey(keys);
62 let sval = self.on_base._ser(val)?;
63
64 self.on_base
65 .base
66 .db
67 .append_on_io_dup_val(
68 &self.on_base.base.sdb,
69 &key,
70 &sval,
71 Some([self.on_base.base.sep]),
72 )
73 .map_err(SuberError::DBError)
74 }
75
76 pub fn get_on<K: AsRef<[u8]>, R: TryFrom<Vec<u8>>>(
78 &self,
79 keys: &[K],
80 on: u32,
81 ) -> Result<Vec<R>, SuberError>
82 where
83 <R as TryFrom<Vec<u8>>>::Error: std::fmt::Debug,
84 {
85 let key = self.on_base._tokey(keys);
86 let mut results = Vec::new();
87
88 self.on_base
89 .base
90 .db
91 .get_on_io_dup_val_iter(
92 &self.on_base.base.sdb,
93 Some(&key),
94 Some(on as u64),
95 Some([self.on_base.base.sep]),
96 |val| {
97 match self.on_base._des(&val) {
99 Ok(deserialized) => {
100 results.push(deserialized);
101 Ok(true) }
103 Err(e) => {
104 Err(DBError::ValueError(format!(
106 "Deserialization error: {:?}",
107 e
108 )))
109 }
110 }
111 },
112 )
113 .map_err(SuberError::DBError)?;
114
115 Ok(results)
116 }
117
118 pub fn rem_on<K: AsRef<[u8]>, V: ?Sized + Clone + Into<Vec<u8>>>(
122 &self,
123 keys: &[K],
124 on: u32,
125 val: Option<&V>,
126 ) -> Result<bool, SuberError> {
127 let key = self.on_base._tokey(keys);
128
129 match val {
130 Some(v) => {
131 let sval = self.on_base._ser(v)?;
132 self.on_base
133 .base
134 .db
135 .del_on_io_dup_val(
136 &self.on_base.base.sdb,
137 &key,
138 Some(on as u64),
139 &sval,
140 Some([self.on_base.base.sep]),
141 )
142 .map_err(SuberError::DBError)
143 }
144 None => self
145 .on_base
146 .base
147 .db
148 .del_on_io_dup_vals(
149 &self.on_base.base.sdb,
150 &key,
151 Some(on as u64),
152 Some([self.on_base.base.sep]),
153 )
154 .map_err(SuberError::DBError),
155 }
156 }
157
158 pub fn get_on_iter<K: AsRef<[u8]>, R: TryFrom<Vec<u8>> + 'static>(
160 &self,
161 keys: &[K],
162 on: u32,
163 ) -> Result<Box<dyn Iterator<Item = Result<R, SuberError>> + '_>, SuberError>
164 where
165 <R as TryFrom<Vec<u8>>>::Error: std::fmt::Debug,
166 SuberError: From<<R as TryFrom<Vec<u8>>>::Error>,
167 {
168 let key = self.on_base._tokey(keys);
169 let sep = self.on_base.base.sep;
170
171 let mut collector = Vec::new();
173
174 self.on_base
176 .base
177 .db
178 .get_on_io_dup_val_iter(
179 &self.on_base.base.sdb,
180 Some(&key),
181 Some(on as u64),
182 Some([sep]),
183 |val| {
184 collector.push(val);
185 Ok(true)
186 },
187 )
188 .map_err(SuberError::DBError)?;
189
190 let iter = collector.into_iter().map(move |val| {
192 let deserialized: R = self.on_base._des(&val)?;
193 Ok(deserialized)
194 });
195
196 Ok(Box::new(iter))
197 }
198
199 pub fn get_on_item_iter<K: AsRef<[u8]>, R: TryFrom<Vec<u8>> + 'static>(
201 &self,
202 keys: &[K],
203 on: u32,
204 ) -> Result<Box<dyn Iterator<Item = Result<(Vec<Vec<u8>>, u64, R), SuberError>> + '_>, SuberError>
205 where
206 <R as TryFrom<Vec<u8>>>::Error: std::fmt::Debug,
207 SuberError: From<<R as TryFrom<Vec<u8>>>::Error>,
208 {
209 let key = self.on_base._tokey(keys);
210 let sep = self.on_base.base.sep;
211
212 let mut collector = Vec::new();
214
215 self.on_base
217 .base
218 .db
219 .get_on_io_dup_item_iter(
220 &self.on_base.base.sdb,
221 Some(&key),
222 Some(on as u64),
223 Some([sep]),
224 |k, o, v| {
225 collector.push((k.to_vec(), o, v.to_vec()));
226 Ok(true)
227 },
228 )
229 .map_err(SuberError::DBError)?;
230
231 let iter = collector.into_iter().map(move |(k, o, v)| {
233 let keys = self.on_base._tokeys(&k);
234 let deserialized: R = self.on_base._des(&v)?;
235 Ok((keys, o, deserialized))
236 });
237
238 Ok(Box::new(iter))
239 }
240
241 pub fn get_on_last_iter<K: AsRef<[u8]>, R: TryFrom<Vec<u8>> + 'static>(
243 &self,
244 keys: &[K],
245 on: u32,
246 ) -> Result<Box<dyn Iterator<Item = Result<R, SuberError>> + '_>, SuberError>
247 where
248 <R as TryFrom<Vec<u8>>>::Error: std::fmt::Debug,
249 SuberError: From<<R as TryFrom<Vec<u8>>>::Error>,
250 {
251 let key = self.on_base._tokey(keys);
252 let sep = self.on_base.base.sep;
253
254 let mut collector = Vec::new();
256
257 self.on_base
259 .base
260 .db
261 .get_on_io_dup_last_val_iter(
262 &self.on_base.base.sdb,
263 Some(&key),
264 Some(on as u64),
265 Some([sep]),
266 |val| {
267 collector.push(val.to_vec());
268 Ok(true)
269 },
270 )
271 .map_err(SuberError::DBError)?;
272
273 let iter = collector
275 .into_iter()
276 .map(move |val| self.on_base._des(&val));
277
278 Ok(Box::new(iter))
279 }
280
281 pub fn get_on_last_item_iter<K: AsRef<[u8]>, R: TryFrom<Vec<u8>> + 'static>(
283 &self,
284 keys: &[K],
285 on: u32,
286 ) -> Result<Box<dyn Iterator<Item = Result<(Vec<Vec<u8>>, u64, R), SuberError>> + '_>, SuberError>
287 where
288 <R as TryFrom<Vec<u8>>>::Error: std::fmt::Debug,
289 SuberError: From<<R as TryFrom<Vec<u8>>>::Error>,
290 {
291 let key = self.on_base._tokey(keys);
292 let sep = self.on_base.base.sep;
293
294 let mut collector = Vec::new();
296
297 self.on_base
299 .base
300 .db
301 .get_on_io_dup_last_item_iter(
302 &self.on_base.base.sdb,
303 Some(&key),
304 Some(on as u64),
305 Some([sep]),
306 |k, o, v| {
307 collector.push((k.to_vec(), o, v.to_vec()));
308 Ok(true)
309 },
310 )
311 .map_err(SuberError::DBError)?;
312
313 let iter = collector.into_iter().map(move |(k, o, v)| {
315 let keys = self.on_base._tokeys(&k);
316 let deserialized: R = self.on_base._des(&v)?;
317 Ok((keys, o, deserialized))
318 });
319
320 Ok(Box::new(iter))
321 }
322
323 pub fn get_on_back_iter<K: AsRef<[u8]>, R: TryFrom<Vec<u8>> + 'static>(
325 &self,
326 keys: &[K],
327 on: u32,
328 ) -> Result<Box<dyn Iterator<Item = Result<R, SuberError>> + '_>, SuberError>
329 where
330 <R as TryFrom<Vec<u8>>>::Error: std::fmt::Debug,
331 SuberError: From<<R as TryFrom<Vec<u8>>>::Error>,
332 {
333 let key = self.on_base._tokey(keys);
334 let sep = self.on_base.base.sep;
335
336 let mut collector = Vec::new();
338
339 self.on_base
341 .base
342 .db
343 .get_on_io_dup_val_back_iter(
344 &self.on_base.base.sdb,
345 Some(&key),
346 Some(on as u64),
347 Some([sep]),
348 |val| {
349 collector.push(val.to_vec());
350 Ok(true)
351 },
352 )
353 .map_err(SuberError::DBError)?;
354
355 let iter = collector
357 .into_iter()
358 .map(move |val| self.on_base._des(&val));
359
360 Ok(Box::new(iter))
361 }
362
363 pub fn get_on_item_back_iter<K: AsRef<[u8]>, R: TryFrom<Vec<u8>> + 'static>(
365 &self,
366 keys: &[K],
367 on: u32,
368 ) -> Result<Box<dyn Iterator<Item = Result<(Vec<Vec<u8>>, u64, R), SuberError>> + '_>, SuberError>
369 where
370 <R as TryFrom<Vec<u8>>>::Error: std::fmt::Debug,
371 SuberError: From<<R as TryFrom<Vec<u8>>>::Error>,
372 {
373 let key = self.on_base._tokey(keys);
374 let sep = self.on_base.base.sep;
375
376 let mut collector = Vec::new();
378
379 self.on_base
381 .base
382 .db
383 .get_on_io_dup_item_back_iter(
384 &self.on_base.base.sdb,
385 Some(&key),
386 Some(on as u64),
387 Some([sep]),
388 |k, o, v| {
389 collector.push((k.to_vec(), o, v.to_vec()));
390 Ok(true)
391 },
392 )
393 .map_err(SuberError::DBError)?;
394
395 let iter = collector.into_iter().map(move |(k, o, v)| {
397 let keys = self.on_base._tokeys(&k);
398 let deserialized: R = self.on_base._des(&v)?;
399 Ok((keys, o, deserialized))
400 });
401
402 Ok(Box::new(iter))
403 }
404
405 pub fn cnt_on<K: AsRef<[u8]>>(&self, keys: &[K], on: u32) -> Result<usize, SuberError> {
414 self.on_base.cnt_on(keys, on)
415 }
416
417 pub fn get_item_iter<K: AsRef<[u8]>>(
427 &self,
428 keys: &[K],
429 topive: bool,
430 ) -> Result<Vec<(Vec<Vec<u8>>, Vec<u8>)>, SuberError> {
431 self.io_dup_suber.get_item_iter(keys, topive)
432 }
433
434 pub fn add<K: AsRef<[u8]>, V: ?Sized + Clone + Into<Vec<u8>>>(
446 &self,
447 keys: &[K],
448 val: &V,
449 ) -> Result<bool, SuberError> {
450 self.io_dup_suber.add(keys, val)
451 }
452
453 pub fn get_last<K: AsRef<[u8]>, R: TryFrom<Vec<u8>>>(
465 &self,
466 keys: &[K],
467 ) -> Result<Option<R>, SuberError>
468 where
469 <R as TryFrom<Vec<u8>>>::Error: std::fmt::Debug,
470 {
471 self.io_dup_suber.get_last(keys)
472 }
473
474 pub fn get_io_dup_val_last<K: AsRef<[u8]>, R: TryFrom<Vec<u8>>>(
475 &self,
476 keys: &[K],
477 ) -> Result<Option<R>, SuberError>
478 where
479 <R as TryFrom<Vec<u8>>>::Error: std::fmt::Debug,
480 {
481 let key = self.on_base._tokey(keys);
483
484 match self
486 .on_base
487 .base
488 .db
489 .get_io_dup_val_last(&self.on_base.base.sdb, &key)
490 {
491 Ok(Some(val_bytes)) => {
492 match self.on_base._des(&val_bytes) {
494 Ok(deserialized) => Ok(Some(deserialized)),
495 Err(e) => Err(e),
496 }
497 }
498 Ok(None) => Ok(None),
499 Err(e) => Err(SuberError::DBError(e)),
500 }
501 }
502
503 pub fn get<K: AsRef<[u8]>, R: TryFrom<Vec<u8>>>(&self, keys: &[K]) -> Result<Vec<R>, SuberError>
504 where
505 <R as TryFrom<Vec<u8>>>::Error: std::fmt::Debug,
506 {
507 self.io_dup_suber.get(keys)
508 }
509
510 pub fn is_dupsort(&self) -> bool {
511 self.on_base.base.is_dupsort()
512 }
513}
514#[cfg(test)]
515mod tests {
516 use crate::keri::db::dbing::keys::on_key;
517 use crate::keri::db::dbing::{LMDBer, LMDBerBuilder};
518 use crate::keri::db::subing::oniodup::OnIoDupSuber;
519 use crate::keri::db::subing::{SuberError, Utf8Codec};
520 use std::sync::Arc;
521 use tempfile::tempdir;
522
523 #[test]
524 fn test_on_iodup_suber() -> Result<(), SuberError> {
525 let temp_dir = tempdir().unwrap();
527 let _dir_path = temp_dir.path().to_path_buf();
528
529 let db = LMDBerBuilder::default()
531 .name("test")
532 .temp(true)
533 .build()
534 .unwrap();
535
536 assert_eq!(db.name(), "test");
537 assert!(db.opened());
538
539 let db_ref = Arc::new(db);
541 let onsuber = OnIoDupSuber::<Utf8Codec>::new(db_ref, "bags.", None, false)?;
542 assert!(onsuber.is_dupsort());
543
544 let w = "Blue dog";
545 let x = "Green tree";
546 let y = "Red apple";
547 let z = "White snow";
548
549 assert!(onsuber.add_on(&["z"], 0, &w)?);
551 let bytes: Vec<Vec<u8>> = onsuber.get_on(&["z"], 0)?;
552 let vals: Vec<String> = bytes
553 .iter()
554 .map(|b| String::from_utf8(b.clone()).unwrap())
555 .collect();
556 assert_eq!(vals, vec![w.to_string()]);
557
558 assert!(onsuber.add_on(&["z"], 0, &x)?);
559 let bytes: Vec<Vec<u8>> = onsuber.get_on(&["z"], 0)?;
560 let vals: Vec<String> = bytes
561 .iter()
562 .map(|b| String::from_utf8(b.clone()).unwrap())
563 .collect();
564 assert_eq!(vals, vec![w.to_string(), x.to_string()]);
565
566 assert!(onsuber.add_on(&["z"], 1, &y)?);
567 let bytes: Vec<Vec<u8>> = onsuber.get_on(&["z"], 1)?;
568 let vals: Vec<String> = bytes
569 .iter()
570 .map(|b| String::from_utf8(b.clone()).unwrap())
571 .collect();
572 assert_eq!(vals, vec![y.to_string()]);
573
574 assert!(onsuber.add_on(&["z"], 1, &z)?);
575 let bytes: Vec<Vec<u8>> = onsuber.get_on(&["z"], 1)?;
576 let vals: Vec<String> = bytes
577 .iter()
578 .map(|b| String::from_utf8(b.clone()).unwrap())
579 .collect();
580 assert_eq!(vals, vec![y.to_string(), z.to_string()]);
581
582 assert_eq!(onsuber.cnt_on(&["z"], 0)?, 4);
583
584 let mut items = Vec::new();
586 let item_iter = onsuber.get_on_item_iter::<_, Vec<u8>>(&["z"], 0)?; for item_result in item_iter {
588 let (keys, on, val) = item_result?;
589 let keys_vec = keys
590 .iter()
591 .map(|k| String::from_utf8(k.clone()).unwrap())
592 .collect::<Vec<_>>();
593 let val_string = String::from_utf8(val).unwrap();
595 items.push((keys_vec, on, val_string));
596 }
597 assert_eq!(
598 items,
599 vec![
600 (vec!["z".to_string()], 0, "Blue dog".to_string()),
601 (vec!["z".to_string()], 0, "Green tree".to_string()),
602 (vec!["z".to_string()], 1, "Red apple".to_string()),
603 (vec!["z".to_string()], 1, "White snow".to_string())
604 ]
605 );
606
607 assert!(onsuber.rem_on(&["z"], 0, Some(&w))?);
609 assert!(onsuber.rem_on(&["z"], 1, None::<&String>)?);
610
611 let mut items = Vec::new();
613 let item_iter = onsuber.get_on_item_iter::<_, Vec<u8>>(&["z"], 0)?;
614 for item_result in item_iter {
615 let (keys, on, val) = item_result?;
616 let keys_vec = keys
617 .iter()
618 .map(|k| String::from_utf8(k.clone()).unwrap())
619 .collect::<Vec<_>>();
620 let val_string = String::from_utf8(val).unwrap();
622 items.push((keys_vec, on, val_string));
623 }
624 assert_eq!(
625 items,
626 vec![(vec!["z".to_string()], 0, "Green tree".to_string())]
627 );
628
629 assert!(onsuber.rem_on(&["z"], 0, Some(&x))?);
630 assert_eq!(onsuber.cnt_on(&["z"], 0)?, 0);
631
632 assert_eq!(onsuber.append_on(&["a"], &w)?, 0);
634 assert_eq!(onsuber.append_on(&["a"], &x)?, 1);
635 assert_eq!(onsuber.append_on(&["a"], &y)?, 2);
636 assert_eq!(onsuber.append_on(&["a"], &z)?, 3);
637
638 assert_eq!(onsuber.cnt_on(&["a"], 2)?, 2);
639 assert_eq!(onsuber.cnt_on(&["a"], 4)?, 0);
640 assert_eq!(onsuber.cnt_on(&["a"], 0)?, 4);
641
642 let raw_items = onsuber.get_item_iter(
644 &["a"] as &[&str],
645 false, )?;
647
648 let items_strings = raw_items
649 .iter()
650 .map(|(keys, val)| {
651 let key_strings = keys
652 .iter()
653 .map(|k| String::from_utf8(k.clone()).unwrap())
654 .collect::<Vec<_>>();
655 (key_strings, String::from_utf8(val.clone()).unwrap())
656 })
657 .collect::<Vec<_>>();
658
659 assert_eq!(items_strings.len(), 4);
661 assert_eq!(items_strings[0].1, "Blue dog");
662 assert_eq!(items_strings[1].1, "Green tree");
663 assert_eq!(items_strings[2].1, "Red apple");
664 assert_eq!(items_strings[3].1, "White snow");
665
666 let mut vals = Vec::new();
668 let val_iter = onsuber.get_on_iter::<_, Vec<u8>>(&["a"], 0)?;
669
670 for val_result in val_iter {
671 let raw_bytes = val_result?;
672 let string_val = String::from_utf8(raw_bytes).expect("Invalid UTF-8 sequence");
673 vals.push(string_val);
674 }
675
676 assert_eq!(
677 vals,
678 vec![
679 "Blue dog".to_string(),
680 "Green tree".to_string(),
681 "Red apple".to_string(),
682 "White snow".to_string()
683 ]
684 );
685
686 let mut vals = Vec::new();
688 let val_iter = onsuber.get_on_iter::<_, Vec<u8>>(&["a"], 2)?;
689 for val_result in val_iter {
690 let raw_bytes = val_result?;
691 let string_val = String::from_utf8(raw_bytes).expect("Invalid UTF-8 sequence");
692 vals.push(string_val);
693 }
694 assert_eq!(
695 vals,
696 vec!["Red apple".to_string(), "White snow".to_string()]
697 );
698
699 let mut items = Vec::new();
701 let item_iter = onsuber.get_on_item_iter::<_, Vec<u8>>(&["a"], 0)?;
702
703 for item_result in item_iter {
704 let (keys, on, raw_bytes) = item_result?;
705 let keys_vec = keys
706 .iter()
707 .map(|k| String::from_utf8(k.clone()).unwrap())
708 .collect::<Vec<_>>();
709 let val = String::from_utf8(raw_bytes).expect("Invalid UTF-8 sequence");
710 items.push((keys_vec, on, val));
711 }
712
713 assert_eq!(
714 items,
715 vec![
716 (vec!["a".to_string()], 0, "Blue dog".to_string()),
717 (vec!["a".to_string()], 1, "Green tree".to_string()),
718 (vec!["a".to_string()], 2, "Red apple".to_string()),
719 (vec!["a".to_string()], 3, "White snow".to_string())
720 ]
721 );
722
723 let mut items = Vec::new();
725 let item_iter = onsuber.get_on_item_iter::<_, Vec<u8>>(&["a"], 2)?;
726 for item_result in item_iter {
727 let (keys, on, raw_bytes) = item_result?;
728 let keys_vec = keys
729 .iter()
730 .map(|k| String::from_utf8(k.clone()).unwrap())
731 .collect::<Vec<_>>();
732 let val = String::from_utf8(raw_bytes).expect("Invalid UTF-8 sequence");
733 items.push((keys_vec, on, val));
734 }
735 assert_eq!(
736 items,
737 vec![
738 (vec!["a".to_string()], 2, "Red apple".to_string()),
739 (vec!["a".to_string()], 3, "White snow".to_string())
740 ]
741 );
742
743 assert!(onsuber.add(&[on_key("b".as_bytes(), 0, None)], &w)?);
745 assert!(onsuber.add(&[on_key("b".as_bytes(), 1, None)], &x)?);
746 assert!(onsuber.add(&[on_key("bc".as_bytes(), 0, None)], &y)?);
747 assert!(onsuber.add(&[on_key("ac".as_bytes(), 0, None)], &z)?);
748
749 assert_eq!(onsuber.cnt_on(&["b"], 0)?, 2);
750 assert_eq!(onsuber.cnt_on(&["ac"], 2)?, 0);
751 assert_eq!(onsuber.cnt_on(&[""], 0)?, 8);
752
753 let mut items = Vec::new();
755 for item_result in onsuber.get_item_iter::<Vec<u8>>(&[] as &[Vec<u8>], false)? {
756 let (keys, raw_bytes) = item_result;
758 let keys_vec = keys
759 .iter()
760 .map(|k| String::from_utf8(k.clone()).unwrap())
761 .collect::<Vec<_>>();
762 let val = String::from_utf8(raw_bytes).expect("Invalid UTF-8 sequence");
763 items.push((keys_vec, val));
764 }
765 assert_eq!(items.len(), 8);
767
768 let mut items = Vec::new();
770 let item_iter = onsuber.get_on_item_iter::<_, Vec<u8>>(&["b"], 0)?;
771 for item_result in item_iter {
772 let (keys, on, raw_bytes) = item_result?;
773 let keys_vec = keys
774 .iter()
775 .map(|k| String::from_utf8(k.clone()).unwrap())
776 .collect::<Vec<_>>();
777 let val = String::from_utf8(raw_bytes).expect("Invalid UTF-8 sequence");
778 items.push((keys_vec, on, val));
779 }
780 assert_eq!(
781 items,
782 vec![
783 (vec!["b".to_string()], 0, "Blue dog".to_string()),
784 (vec!["b".to_string()], 1, "Green tree".to_string())
785 ]
786 );
787
788 let mut vals = Vec::new();
790 let val_iter = onsuber.get_on_iter::<_, Vec<u8>>(&["b"], 0)?;
791 for val_result in val_iter {
792 let raw_bytes = val_result?;
793 let string_val = String::from_utf8(raw_bytes).expect("Invalid UTF-8 sequence");
794 vals.push(string_val);
795 }
796 assert_eq!(vals, vec!["Blue dog".to_string(), "Green tree".to_string()]);
797
798 let mut vals = Vec::new();
800 let val_iter = onsuber.get_on_iter::<_, Vec<u8>>(&["b"], 0)?;
801 for val_result in val_iter {
802 let raw_bytes = val_result?;
803 let string_val = String::from_utf8(raw_bytes).expect("Invalid UTF-8 sequence");
804 vals.push(string_val);
805 }
806 assert_eq!(vals, vec!["Blue dog".to_string(), "Green tree".to_string()]);
807
808 let mut items = Vec::new();
810 let item_iter = onsuber.get_on_item_iter::<_, Vec<u8>>(&["b"], 0)?;
811 for item_result in item_iter {
812 let (keys, on, raw_bytes) = item_result?;
813 let keys_vec = keys
814 .iter()
815 .map(|k| String::from_utf8(k.clone()).unwrap())
816 .collect::<Vec<_>>();
817 let val = String::from_utf8(raw_bytes).expect("Invalid UTF-8 sequence");
818 items.push((keys_vec, on, val));
819 }
820 assert_eq!(
821 items,
822 vec![
823 (vec!["b".to_string()], 0, "Blue dog".to_string()),
824 (vec!["b".to_string()], 1, "Green tree".to_string())
825 ]
826 );
827
828 let mut items = Vec::new();
830 let item_iter = onsuber.get_on_item_iter::<_, Vec<u8>>(&["b", ""], 0)?;
831 for item_result in item_iter {
832 let (keys, on, raw_bytes) = item_result?;
833 let keys_vec = keys
834 .iter()
835 .map(|k| String::from_utf8(k.clone()).unwrap())
836 .collect::<Vec<_>>();
837 let val = String::from_utf8(raw_bytes).expect("Invalid UTF-8 sequence");
838 items.push((keys_vec, on, val));
839 }
840 assert!(items.is_empty());
841
842 let mut vals = Vec::new();
844 let val_iter = onsuber.get_on_iter::<_, Vec<u8>>(&["b", ""], 0)?;
845 for val_result in val_iter {
846 vals.push(val_result?);
847 }
848 assert!(vals.is_empty());
849
850 let mut items = Vec::new();
852 let item_iter = onsuber.get_on_item_iter::<_, Vec<u8>>(&[""], 0)?;
853 for item_result in item_iter {
854 let (keys, on, val) = item_result?;
855 let keys_vec = keys
856 .iter()
857 .map(|k| String::from_utf8(k.clone()).unwrap())
858 .collect::<Vec<_>>();
859 items.push((keys_vec, on, val));
860 }
861 assert_eq!(items.len(), 8);
862
863 let mut vals = Vec::new();
865 let val_iter = onsuber.get_on_iter::<_, Vec<u8>>(&[""], 0)?;
866 for val_result in val_iter {
867 vals.push(val_result?);
868 }
869 assert_eq!(vals.len(), 8);
870
871 let mut items = Vec::new();
873 let item_iter = onsuber.get_on_item_iter::<&str, Vec<u8>>(&[], 0)?;
874 for item_result in item_iter {
875 let (keys, on, val) = item_result?;
876 let keys_vec = keys
877 .iter()
878 .map(|k| String::from_utf8(k.clone()).unwrap())
879 .collect::<Vec<_>>();
880 items.push((keys_vec, on, val));
881 }
882 assert_eq!(items.len(), 8);
883
884 let mut vals = Vec::new();
886 let val_iter = onsuber.get_on_iter::<&str, Vec<u8>>(&[], 0)?;
887 for val_result in val_iter {
888 vals.push(val_result?);
889 }
890 assert_eq!(vals.len(), 8);
891
892 assert!(onsuber.add(&[on_key("a".as_bytes(), 0, None)], &z)?);
894 assert!(onsuber.add(&[on_key("a".as_bytes(), 1, None)], &y)?);
895 assert!(onsuber.add(&[on_key("a".as_bytes(), 2, None)], &x)?);
896 assert!(onsuber.add(&[on_key("a".as_bytes(), 3, None)], &w)?);
897
898 assert_eq!(onsuber.cnt_on(&["a"], 0)?, 8);
899 assert_eq!(onsuber.cnt_on(&["a"], 2)?, 4);
900 assert_eq!(onsuber.cnt_on(&["a"], 4)?, 0);
901
902 let mut items = Vec::new();
904 let item_iter = onsuber.get_on_item_iter::<_, Vec<u8>>(&["a"], 0)?;
905 for item_result in item_iter {
906 let (keys, on, val) = item_result?;
907 let keys_vec = keys
908 .iter()
909 .map(|k| String::from_utf8(k.clone()).unwrap())
910 .collect::<Vec<_>>();
911 items.push((keys_vec, on, val));
912 }
913 assert_eq!(items.len(), 8);
914
915 let mut vals = Vec::new();
916 let val_iter = onsuber.get_on_iter::<_, Vec<u8>>(&["a"], 0)?;
917 for val_result in val_iter {
918 vals.push(val_result?);
919 }
920 assert_eq!(vals.len(), 8);
921
922 let mut items = Vec::new();
924 let item_iter = onsuber.get_on_item_back_iter::<_, Vec<u8>>(&["a"], 4)?;
925 for item_result in item_iter {
926 let (keys, on, val) = item_result?;
927 let keys_vec = keys
928 .iter()
929 .map(|k| String::from_utf8(k.clone()).unwrap())
930 .collect::<Vec<_>>();
931 items.push((keys_vec, on, val));
932 }
933 assert_eq!(items.len(), 8);
934
935 let mut vals = Vec::new();
936 let val_iter = onsuber.get_on_back_iter::<_, Vec<u8>>(&["a"], 4)?;
937 for val_result in val_iter {
938 vals.push(val_result?);
939 }
940 assert_eq!(vals.len(), 8);
941
942 let mut items = Vec::new();
944 let item_iter = onsuber.get_on_item_iter::<_, Vec<u8>>(&["a"], 2)?;
945 for item_result in item_iter {
946 let (keys, on, val) = item_result?;
947 let keys_vec = keys
948 .iter()
949 .map(|k| String::from_utf8(k.clone()).unwrap())
950 .collect::<Vec<_>>();
951 items.push((keys_vec, on, val));
952 }
953 assert_eq!(items.len(), 4);
954
955 let mut vals = Vec::new();
956 let val_iter = onsuber.get_on_iter::<_, Vec<u8>>(&["a"], 2)?;
957 for val_result in val_iter {
958 vals.push(val_result?);
959 }
960 assert_eq!(vals.len(), 4);
961
962 let mut items = Vec::new();
964 let item_iter = onsuber.get_on_item_back_iter::<_, Vec<u8>>(&["a"], 1)?;
965 for item_result in item_iter {
966 let (keys, on, val) = item_result?;
967 let keys_vec = keys
968 .iter()
969 .map(|k| String::from_utf8(k.clone()).unwrap())
970 .collect::<Vec<_>>();
971 items.push((keys_vec, on, val));
972 }
973 assert_eq!(items.len(), 4);
974
975 let mut vals = Vec::new();
976 let val_iter = onsuber.get_on_back_iter::<_, Vec<u8>>(&["a"], 1)?;
977 for val_result in val_iter {
978 vals.push(val_result?);
979 }
980 assert_eq!(vals.len(), 4);
981
982 assert_eq!(onsuber.append_on(&["a"], &x)?, 4);
984 assert_eq!(onsuber.cnt_on(&["a"], 0)?, 9);
985
986 assert!(onsuber.rem_on(&["a"], 1, None::<&String>)?);
988 assert!(!onsuber.rem_on(&["a"], 1, None::<&String>)?);
989 assert!(onsuber.rem_on(&["a"], 3, None::<&String>)?);
990 assert!(!onsuber.rem_on(&["a"], 3, None::<&String>)?);
991
992 assert_eq!(onsuber.cnt_on(&["a"], 0)?, 5);
993
994 let mut items = Vec::new();
996 let item_iter = onsuber.get_on_item_iter::<_, Vec<u8>>(&["a"], 0)?;
997 for item_result in item_iter {
998 let (keys, on, val) = item_result?;
999 let keys_vec = keys
1000 .iter()
1001 .map(|k| String::from_utf8(k.clone()).unwrap())
1002 .collect::<Vec<_>>();
1003 items.push((keys_vec, on, val));
1004 }
1005 assert_eq!(items.len(), 5);
1006
1007 Ok(())
1008 }
1009}