use super::*; use std::borrow::Borrow; use std::marker::PhantomData; use std::iter; use std::collections::{ btree_map::Range, VecDeque, }; use smallvec::SmallVec; #[derive(Debug)] pub struct StoreSearchIter<'a, T: ?Sized>(&'a Store, Option>, VecDeque<&'a sha256::Sha256Hash>, PhantomData); // Accessing impl Store { //TODO: Parallelize this with futures::Stream ver to do the `tag_search` lookups in parallel. pub fn tag_search_all<'a, T: ?Sized + Ord + 'a>(&'a self, tags: impl IntoIterator) -> impl Iterator + 'a where String: Borrow { let tags: SmallVec<[_; 5]> = tags.into_iter().collect(); tags.iter().flat_map(|&tag| self.tag_search(tag)).dedup_ref() .filter(|x| x.tags.iter().map(|x| x.borrow()).filter(|tx| !tags.contains(tx)).count() == 0) /* TODO: get rid of this ,replace `impl Iterator` return with its own type. */ .collect::>().into_iter() } /// Search for all entries with *any* of these provided tags. /// /// # Notes /// This is allowed to produce duplicate entries, if either: /// * An entry has multiple of the same tag set /// * An entry has multiple of the tags provided to this function set pub fn tag_search_any<'a, T: ?Sized + Ord + 'a>(&self, tags: impl IntoIterator) -> StoreSearchIter<'_, T> where String: Borrow { let mut sorted: SmallVec<[_; 5]> = tags.into_iter().collect(); sorted.sort(); StoreSearchIter(self, Some(match (sorted.first(), sorted.last()) { (Some(&low), Some(&high)) => self.tags.range::((std::ops::Bound::Included(low), std::ops::Bound::Included(high))), _ => return StoreSearchIter(self, None, Default::default(), PhantomData), }), VecDeque::new(), PhantomData) } /// Search for all items with this provided tag. /// /// # Notes /// This is allowed to produce duplicate entries, if an entry has two of the same tags set. pub fn tag_search<'a, T: ?Sized + Ord>(&'a self, tag: &T) -> StoreSearchIter<'a, T> where String: Borrow { let r= (std::ops::Bound::Included(tag), std::ops::Bound::Included(tag)); StoreSearchIter(self, Some(self.tags.range::(r)), VecDeque::new(), PhantomData) } fn _assert_test_search(&self) { let _x: Vec<_> = self.tag_search_any(vec!["hello", "one", "two"]).dedup_ref().collect(); } } impl<'a, T: ?Sized> Iterator for StoreSearchIter<'a, T> { type Item = &'a Entry; fn next(&mut self) -> Option { if let Some(range) = &mut self.1 { if let Some((_, &ti)) = range.next() { // tag index get let data_hashes = &self.0.data_hashes; let iter = self.0.tag_mappings.get(ti) .map_into_iter() .filter_map(move |&idx| data_hashes.get(idx)); self.2.extend(iter); } } else { return None; } self.2.pop_front().map(|x| self.0.data.get(x)).flatten() } fn size_hint(&self) -> (usize, Option) { match self.1 { None => (0, Some(0)), Some(_) => (0, None), } } } impl<'a, T: ?Sized> iter::FusedIterator for StoreSearchIter<'a, T>{}