removed public visibility of some library internals

examples/benchmark.rs

@@ -1,11 +1,8 @@
 extern crate levtree;
 
-
-use levtree::CaseSensitiveKeyChecker;
 use levtree::CaseSensitiveLevTrie;
 use levtree::DamerauLevenshteinDistanceCalculator;
 use levtree::LevTrie;
-use levtree::Trie;
 
 use std::io::BufRead;
 use std::io::BufReader;

src/levtrie.rs

@@ -9,8 +9,8 @@ use super::trie::VisitOutcome;
 use super::trienode::TrieKey;
 use super::trienode::TrieNode;
 
-pub type LevTrie<KEY, KEYCHECKER> = Trie<KEY, KEYCHECKER, ()>;
+pub type LevTrie<KEY, KEYCHECKER> = Trie<KEY, KEYCHECKER>;
-pub type LevTrieNode<KEY> = TrieNode<KEY, ()>;
+pub type LevTrieNode<KEY> = TrieNode<KEY>;
 
 #[sealed]
 pub trait DistanceCalculator<KEY, KEYCHECKER>
@@ -33,7 +33,7 @@ where
     KEYCHECKER: KeyChecker<KEY>,
 {
     pub fn new() -> LevTrie<KEY, KEYCHECKER> {
-        Trie::empty(|| {})
+        Trie::empty()
     }
 
     pub fn from_words<T: IntoIterator, U: IntoIterator>(wordlist: U) -> LevTrie<KEY, KEYCHECKER>

src/mod.rs

@@ -1,24 +0,0 @@
-#[macro_use] extern crate trait_group;
-mod levtrie;
-// pub use self::levtrie::LevTrieNode as LevTrieNode;
-pub use self::levtrie::LevTrie;
-pub use self::levtrie::DistanceCalculator;
-pub use self::levtrie::DamerauLevenshteinDistanceCalculator;
-pub use self::levtrie::LevenshteinDistanceCalculator;
-
-mod trie;
-pub use self::trie::Trie as Trie;
-
-mod trienode;
-//use self::trienode::TrieNode as TrieNode;
-
-mod keychecker;
-pub use self::keychecker::KeyChecker;
-pub use self::keychecker::CaseSensitiveKeyChecker;
-pub use self::keychecker::CaseInsensitiveKeyChecker;
-
-pub type CaseSensitiveLevTrie = LevTrie<char, CaseSensitiveKeyChecker>;
-pub type CaseInSensitiveLevTrie = LevTrie<char, CaseInsensitiveKeyChecker>;
-
-mod result;
-pub use self::result::Result;

src/trie.rs

@@ -1,10 +1,7 @@
 use std::collections::BTreeSet;
-use std::collections::HashMap;
 use std::marker::PhantomData;
 
 use super::keychecker::KeyChecker;
-use super::levtrie::DistanceCalculator;
-use super::result::Result;
 use super::trienode::TrieKey;
 use super::trienode::TrieNode;
 
@@ -14,60 +11,57 @@ pub enum VisitOutcome {
     EarlyExit,
 }
 
-pub struct Trie<KEY, KEYCHECKER, PAYLOAD>
+pub struct Trie<KEY, KEYCHECKER>
 where
     KEY: TrieKey,
     KEYCHECKER: KeyChecker<KEY>,
 {
-    pub nodes: Vec<TrieNode<KEY, PAYLOAD>>,
+    pub (crate) nodes: Vec<TrieNode<KEY>>,
-    payload_initializer: fn() -> PAYLOAD,
     tails: BTreeSet<usize>,
     checker: PhantomData<KEYCHECKER>,
 }
 
-impl<KEY, KEYCHECKER, PAYLOAD> Trie<KEY, KEYCHECKER, PAYLOAD>
+impl<KEY, KEYCHECKER> Trie<KEY, KEYCHECKER>
 where
     KEY: TrieKey,
     KEYCHECKER: KeyChecker<KEY>,
 {
-    pub fn empty(initializer: fn() -> PAYLOAD) -> Trie<KEY, KEYCHECKER, PAYLOAD> {
+    pub fn empty() -> Trie<KEY, KEYCHECKER> {
         Trie {
-            nodes: vec![TrieNode::new0(None, initializer)],
+            nodes: vec![TrieNode::new0(None)],
-            payload_initializer: initializer,
             tails: BTreeSet::new(),
             checker: PhantomData::default(),
         }
     }
 
     pub fn trie_from_words<T: IntoIterator, U: IntoIterator>(
-        initializer: fn() -> PAYLOAD,
         wordlist: U,
-    ) -> Trie<KEY, KEYCHECKER, PAYLOAD>
+    ) -> Trie<KEY, KEYCHECKER>
     where
         T: IntoIterator<Item = KEY>,
         U: IntoIterator<Item = T>,
     {
-        let mut result = Trie::empty(initializer);
+        let mut result = Trie::empty();
         for word in wordlist {
             result.add(word);
         }
         result
     }
 
-    pub fn get_node_mut(&mut self, index: usize) -> &mut TrieNode<KEY, PAYLOAD> {
+    pub (crate) fn get_node_mut(&mut self, index: usize) -> &mut TrieNode<KEY> {
         &mut self.nodes[index]
     }
 
-    pub fn get_node(&self, index: usize) -> &TrieNode<KEY, PAYLOAD> {
+    pub (crate) fn get_node(&self, index: usize) -> &TrieNode<KEY> {
         &self.nodes[index]
     }
 
-    pub fn nodes(&self) -> usize {
+    pub (crate) fn nodes(&self) -> usize {
         self.nodes.len()
     }
 
     fn add_node(&mut self, key: Option<KEY>, parent: usize, prev: Option<usize>) -> usize {
-        let mut result = TrieNode::new0(key, self.payload_initializer);
+        let mut result = TrieNode::new0(key);
         let result_index = self.nodes();
         result.parent = Some(parent);
         match prev {
@@ -178,7 +172,7 @@ where
                 }
             }
         };
-        let visit_post = |stack: &Vec<usize>| {};
+        let visit_post = |_: &Vec<usize>| {};
         self.walk(visit_pre, visit_post);
         result
     }
@@ -207,7 +201,7 @@ where
         chars
     }
 
-    pub fn walk<CB1, CB2>(&self, mut visit_pre: CB1, mut visit_post: CB2)
+    pub (crate) fn walk<CB1, CB2>(&self, mut visit_pre: CB1, mut visit_post: CB2)
     where
         CB1: FnMut(&Vec<usize>) -> VisitOutcome,
         CB2: FnMut(&Vec<usize>),
@@ -249,3 +243,4 @@ where
         &self.tails
     }
 }
+

src/trienode.rs

@@ -2,39 +2,32 @@ trait_group! {
     pub trait TrieKey : std::marker::Copy + std::fmt::Display + Sized
 }
 
-// pub trait KeyPath<KEY: TrieKey> : std::ops::Index<usize> + IntoIterator<Item = KEY> {}
+pub struct TrieNode<KEY>
-
-pub struct TrieNode<KEY, PAYLOAD>
 where
     KEY: TrieKey,
 {
     pub key: Option<KEY>,
-    pub payload: PAYLOAD,
     pub prev: Option<usize>,
     pub next: Option<usize>,
     pub child: Option<usize>,
     pub parent: Option<usize>,
-    pub ref_count: usize,
+    pub (crate) ref_count: usize,
 }
 
-impl<KEY, PAYLOAD> TrieNode<KEY, PAYLOAD>
+impl<KEY> TrieNode<KEY>
 where
     KEY: TrieKey,
 {
-    fn new<U>(
+    fn new(
         key: Option<KEY>,
-        payload_initializer: U,
         prev: Option<usize>,
         next: Option<usize>,
         parent: Option<usize>,
         child: Option<usize>,
-    ) -> TrieNode<KEY, PAYLOAD>
+    ) -> TrieNode<KEY>
-    where
-        U: Fn() -> PAYLOAD,
     {
         TrieNode {
             key,
-            payload: payload_initializer(),
             prev: prev,
             next: next,
             child: child,
@@ -43,10 +36,8 @@ where
         }
     }
 
-    pub fn new0<U>(key: Option<KEY>, payload_initializer: U) -> TrieNode<KEY, PAYLOAD>
+    pub (crate) fn new0(key: Option<KEY>) -> TrieNode<KEY>
-    where
-        U: Fn() -> PAYLOAD,
     {
-        TrieNode::new(key, payload_initializer, None, None, None, None)
+        TrieNode::new(key, None, None, None, None)
     }
 }