From e35c11e051a559fc03f724223ce67f9e8d955289 Mon Sep 17 00:00:00 2001
From: Shane Celis <shane.celis@gmail.com>
Date: Sun, 28 Apr 2024 05:56:08 -0400
Subject: [PATCH] excise: Comment out code dependent on laysakura/louds-rs#14.

If that PR gets merged, we'll put it back.
---
 Cargo.toml        |  3 +-
 src/inc_search.rs | 81 +++++++++++++++++++++++++++++++----------------
 src/map.rs        |  2 +-
 src/map/trie.rs   |  8 ++---
 4 files changed, 59 insertions(+), 35 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 0fd2fbd..c2aa36d 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -12,8 +12,7 @@ categories = ["compression", "data-structures"]
 edition = "2021"
 
 [dependencies]
-# louds-rs = "0.6"
-louds-rs = { path = "../louds-rs" }
+louds-rs = "0.6"
 mem_dbg = { version = "0.1.4", optional = true }
 serde = { version = "1.0", features = ["derive"], optional = true }
 
diff --git a/src/inc_search.rs b/src/inc_search.rs
index 04a2ea2..211a494 100644
--- a/src/inc_search.rs
+++ b/src/inc_search.rs
@@ -40,7 +40,7 @@
 //! the loop.
 use crate::{
     map::Trie,
-    try_collect::{TryCollect, TryFromIterator},
+    // try_collect::{TryCollect, TryFromIterator},
 };
 use louds_rs::LoudsNodeNum;
 
@@ -184,16 +184,34 @@ impl<'a, Label: Ord, Value> IncSearch<'a, Label, Value> {
         self.trie.value(self.node)
     }
 
-    /// Return the current prefix for this search.
-    pub fn prefix<C, M>(&self) -> C
-    where
-        C: TryFromIterator<Label, M>,
-        Label: Clone,
-    {
-        let mut v: Vec<Label> = self.trie.child_to_ancestors(self.node)
-            .map(|node| self.trie.label(node).clone()).collect();
-        v.reverse();
-        v.into_iter().try_collect().expect("Could not collect")
+    // Return the current prefix for this search.
+    // pub fn prefix<C, M>(&self) -> C
+    // where
+    //     C: TryFromIterator<Label, M>,
+    //     Label: Clone,
+    // {
+    //     let mut v: Vec<Label> = self.trie.child_to_ancestors(self.node)
+    //         .map(|node| self.trie.label(node).clone()).collect();
+    //     v.reverse();
+    //     v.into_iter().try_collect().expect("Could not collect")
+    // }
+
+    /// Returne the length of the current prefix for this search.
+    pub fn prefix_len(&self) -> usize {
+        // TODO: If PR for child_to_ancestors is accepted. Use the iterator and
+        // remove `pub(crate)` from Trie.louds field. Also uncomment prefix()
+        // above.
+
+        // self.trie.child_to_ancestors(self.node).count()
+
+        let mut node = self.node;
+        let mut count = 0;
+        while node.0 > 1 {
+            let index = self.trie.louds.node_num_to_index(node);
+            node = self.trie.louds.child_to_parent(index);
+            count += 1;
+        }
+        count
     }
 
     // This isn't actually possible.
@@ -232,38 +250,45 @@ mod search_tests {
     fn inc_search() {
         let trie = build_trie();
         let mut search = trie.inc_search();
-        assert_eq!("", search.prefix::<String, _>());
+        // assert_eq!("", search.prefix::<String, _>());
+        assert_eq!(0, search.prefix_len());
         assert_eq!(None, search.query(&b'z'));
-        assert_eq!("", search.prefix::<String, _>());
+        // assert_eq!("", search.prefix::<String, _>());
+        assert_eq!(0, search.prefix_len());
         assert_eq!(Answer::PrefixAndMatch, search.query(&b'a').unwrap());
-        assert_eq!("a", search.prefix::<String, _>());
+        // assert_eq!("a", search.prefix::<String, _>());
+        assert_eq!(1, search.prefix_len());
         assert_eq!(Answer::Prefix, search.query(&b'p').unwrap());
-        assert_eq!("ap", search.prefix::<String, _>());
+        // assert_eq!("ap", search.prefix::<String, _>());
+        assert_eq!(2, search.prefix_len());
         assert_eq!(Answer::PrefixAndMatch, search.query(&b'p').unwrap());
-        assert_eq!("app", search.prefix::<String, _>());
+        // assert_eq!("app", search.prefix::<String, _>());
+        assert_eq!(3, search.prefix_len());
         assert_eq!(Answer::Prefix, search.query(&b'l').unwrap());
-        assert_eq!("appl", search.prefix::<String, _>());
+        // assert_eq!("appl", search.prefix::<String, _>());
+        assert_eq!(4, search.prefix_len());
         assert_eq!(Answer::Match, search.query(&b'e').unwrap());
-        assert_eq!("apple", search.prefix::<String, _>());
+        // assert_eq!("apple", search.prefix::<String, _>());
+        assert_eq!(5, search.prefix_len());
     }
 
     #[test]
     fn inc_search_value() {
         let trie = build_trie();
         let mut search = trie.inc_search();
-        assert_eq!("", search.prefix::<String, _>());
+        // assert_eq!("", search.prefix::<String, _>());
         assert_eq!(None, search.query(&b'z'));
-        assert_eq!("", search.prefix::<String, _>());
+        // assert_eq!("", search.prefix::<String, _>());
         assert_eq!(Answer::PrefixAndMatch, search.query(&b'a').unwrap());
-        assert_eq!("a", search.prefix::<String, _>());
+        // assert_eq!("a", search.prefix::<String, _>());
         assert_eq!(Answer::Prefix, search.query(&b'p').unwrap());
-        assert_eq!("ap", search.prefix::<String, _>());
+        // assert_eq!("ap", search.prefix::<String, _>());
         assert_eq!(Answer::PrefixAndMatch, search.query(&b'p').unwrap());
-        assert_eq!("app", search.prefix::<String, _>());
+        // assert_eq!("app", search.prefix::<String, _>());
         assert_eq!(Answer::Prefix, search.query(&b'l').unwrap());
-        assert_eq!("appl", search.prefix::<String, _>());
+        // assert_eq!("appl", search.prefix::<String, _>());
         assert_eq!(Answer::Match, search.query(&b'e').unwrap());
-        assert_eq!("apple", search.prefix::<String, _>());
+        // assert_eq!("apple", search.prefix::<String, _>());
         assert_eq!(Some(&2), search.value());
     }
 
@@ -272,13 +297,13 @@ mod search_tests {
         let trie = build_trie();
         let mut search = trie.inc_search();
         assert_eq!(Err(0), search.query_until("zoo"));
-        assert_eq!("", search.prefix::<String, _>());
+        // assert_eq!("", search.prefix::<String, _>());
         search.reset();
         assert_eq!(Err(1), search.query_until("blue"));
-        assert_eq!("b", search.prefix::<String, _>());
+        // assert_eq!("b", search.prefix::<String, _>());
         search.reset();
         assert_eq!(Answer::Match, search.query_until("apple").unwrap());
-        assert_eq!("apple", search.prefix::<String, _>());
+        // assert_eq!("apple", search.prefix::<String, _>());
         assert_eq!(Some(&2), search.value());
     }
 
diff --git a/src/map.rs b/src/map.rs
index 11b5689..b76a9fc 100644
--- a/src/map.rs
+++ b/src/map.rs
@@ -13,7 +13,7 @@ use mem_dbg::MemDbg;
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 /// A trie for sequences of the type `Label`; each sequence has an associated `Value`.
 pub struct Trie<Label, Value> {
-    louds: Louds,
+    pub(crate) louds: Louds,
 
     /// (LoudsNodeNum - 2) -> TrieLabel
     trie_labels: Vec<TrieLabel<Label, Value>>,
diff --git a/src/map/trie.rs b/src/map/trie.rs
index 32dcf7e..cc25324 100644
--- a/src/map/trie.rs
+++ b/src/map/trie.rs
@@ -3,7 +3,7 @@ use super::Trie;
 use crate::inc_search::IncSearch;
 use crate::iter::{PostfixIter, PrefixIter, SearchIter};
 use crate::try_collect::{TryCollect, TryFromIterator};
-use louds_rs::{ChildNodeIter, LoudsNodeNum, AncestorNodeIter};
+use louds_rs::{ChildNodeIter, LoudsNodeNum};
 use std::iter::FromIterator;
 
 impl<Label: Ord, Value> Trie<Label, Value> {
@@ -211,9 +211,9 @@ impl<Label: Ord, Value> Trie<Label, Value> {
         self.trie_labels[(node_num.0 - 2) as usize].value.as_mut()
     }
 
-    pub (crate) fn child_to_ancestors(&self, node_num: LoudsNodeNum) -> AncestorNodeIter {
-        self.louds.child_to_ancestors(node_num)
-    }
+    // pub (crate) fn child_to_ancestors(&self, node_num: LoudsNodeNum) -> AncestorNodeIter {
+    //     self.louds.child_to_ancestors(node_num)
+    // }
 }
 
 impl<Label, Value, C> FromIterator<(C, Value)> for Trie<Label, Value>