multiple texts

src/lib.rs

@@ -145,6 +145,7 @@ mod rlfmi;
 mod sais;
 mod seal;
 mod search;
+mod text_builder;
 mod util;
 
 pub use crate::fm_index::FMIndex;

src/search.rs

@@ -8,6 +8,7 @@ use crate::character::Character;
 use crate::fm_index::FMIndex;
 #[cfg(doc)]
 use crate::rlfmi::RLFMIndex;
+use crate::text_builder::TextId;
 
 /// A search index.
 ///
@@ -24,6 +25,53 @@ pub trait SearchIndex: BackwardIterableIndex {
     {
         Search::new(self).search(pattern)
     }
+
+    // If we created a HasDoc trait (or something better named) for those
+    // indexes that maintain the `Doc` structure, we could move the following
+    // methods into a trait that depends on that.
+
+    /// Given a text id, return the text associated with it.
+    ///
+    /// This is the actual text, excluding zero separators.
+    fn text(&self, id: TextId) -> Vec<Self::T> {
+        todo!()
+    }
+
+    /// Search for texts that contain pattern.
+    ///
+    ///
+    /// This is identical to search(), except if pattern were to
+    /// contain a null character. (should we allow it?)
+    fn search_contains<K>(&self, pattern: K) -> Search<Self>
+    where
+        K: AsRef<[Self::T]>,
+    {
+        todo!();
+    }
+
+    /// Search for texts that start with pattern.
+    fn search_start_with<K>(&self, pattern: K) -> Search<Self>
+    where
+        K: AsRef<[Self::T]>,
+    {
+        todo!();
+    }
+
+    /// Search for texts that end with pattern.
+    fn search_ends_with<K>(&self, pattern: K) -> Search<Self>
+    where
+        K: AsRef<[Self::T]>,
+    {
+        todo!();
+    }
+
+    /// Search for texts that are exactly pattern.
+    fn search_exact<K>(&self, pattern: K) -> Search<Self>
+    where
+        K: AsRef<[Self::T]>,
+    {
+        todo!();
+    }
 }
 
 impl<I: BackwardIterableIndex> SearchIndex for I {}
@@ -135,4 +183,85 @@ where
         }
         results
     }
+
+    /// List the position of all occurrences with an iterator.
+    ///
+    /// TODO: we could also provide an `IntoIterator` for seach that returns this.
+    pub fn locate_iter(&self) -> LocationInfoIterator<I> {
+        LocationInfoIterator::new(self.index, self.s, self.e)
+    }
+}
+
+pub struct LocationInfoIterator<'a, I>
+where
+    I: SearchIndex + HasPosition,
+{
+    index: &'a I,
+    k_iterator: std::ops::Range<u64>,
+}
+
+impl<'a, I> LocationInfoIterator<'a, I>
+where
+    I: SearchIndex + HasPosition,
+{
+    pub fn new(index: &'a I, start: u64, end: u64) -> Self {
+        LocationInfoIterator {
+            index,
+            k_iterator: start..end,
+        }
+    }
+}
+
+impl<'a, I> Iterator for LocationInfoIterator<'a, I>
+where
+    I: SearchIndex + HasPosition,
+{
+    type Item = LocationInfo<'a, I>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let k = self.k_iterator.next()?;
+        Some(LocationInfo {
+            index: self.index,
+            k,
+        })
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.k_iterator.size_hint()
+    }
+}
+
+pub struct LocationInfo<'a, I>
+where
+    I: SearchIndex + HasPosition,
+{
+    index: &'a I,
+    k: u64,
+}
+
+impl<I> LocationInfo<'_, I>
+where
+    I: SearchIndex + HasPosition,
+{
+    /// the position of a location within the larger text
+    pub fn position(&self) -> u64 {
+        self.index.get_sa::<seal::Local>(self.k)
+    }
+
+    // the existence of the following methods could depend on the
+    // `HasDoc` trait.
+
+    /// the text id that the location belongs to.
+    ///
+    /// Each 0 separated text has a unique id identifying it.
+    pub fn text_id(&self) -> TextId {
+        todo!()
+    }
+
+    /// the original text at this text id
+    ///
+    /// This does not include the 0 characters at its boundaries.
+    pub fn text(&self) -> Vec<I::T> {
+        todo!()
+    }
 }

src/text_builder.rs

@@ -0,0 +1,44 @@
+use crate::Character;
+
+/// A text builder lets you construct a text from multiple parts.
+/// Internally each part is separated by the 0 character.
+pub struct TextBuilder<T>
+where
+    T: Character,
+{
+    id_counter: usize,
+    text: Vec<T>,
+}
+
+/// A unique id identifying this text.
+#[derive(Clone, Copy, Debug, Eq, PartialEq, PartialOrd, Ord, Hash)]
+pub struct TextId(usize);
+
+impl<T> TextBuilder<T>
+where
+    T: Character,
+{
+    /// Create a new empty text builder.
+    pub fn new() -> TextBuilder<T> {
+        TextBuilder {
+            id_counter: 0,
+            text: vec![],
+        }
+    }
+
+    /// Add a text to the builder.
+    ///
+    /// Returns a unique id for this text.
+    fn add_text(&mut self, text: &[T]) -> TextId {
+        let id = TextId(self.id_counter);
+        self.id_counter += 1;
+        self.text.extend_from_slice(text);
+        self.text.push(T::zero());
+        id
+    }
+
+    /// Finish the build and return the text.
+    fn build(self) -> Vec<T> {
+        self.text
+    }
+}