Re-orgnized, added some documentation

Author: eranmeir

Sufa/SuffixArray.cs

@@ -26,62 +26,6 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 
 namespace Sufa
 {
-    [Serializable]
-    internal class Chain : IComparable<Chain>
-    {
-        public int head;
-        public int length;
-        private string m_str;
-
-        public Chain(string str)
-        {
-            m_str = str;
-        }
-
-        public int CompareTo(Chain other)
-        {
-            return m_str.Substring(head, length).CompareTo(m_str.Substring(other.head, other.length));
-        }
-
-        public override string ToString()
-        {
-            return m_str.Substring(head, length);
-        }
-    }
-
-    [Serializable]
-    internal class CharComparer : System.Collections.Generic.EqualityComparer<char>
-    {
-        public override bool Equals(char x, char y)
-        {
-            return x.Equals(y);
-        }
-
-        public override int GetHashCode(char obj)
-        {
-            return obj.GetHashCode();
-        }
-    }
-
-    internal struct SuffixRank
-    {
-        public int head;
-        public int rank;
-    }
-
-    class SuffixRankComparer : IComparer<SuffixRank>
-    {
-        public bool Equals(SuffixRank x, SuffixRank y)
-        {
-            return x.rank.Equals(y.rank);
-        }
-
-        public int Compare(SuffixRank x, SuffixRank y)
-        {
-            return x.rank.CompareTo(y.rank);
-        }
-    }
-
     [Serializable]
     public class SuffixArray
     {
@@ -91,10 +35,9 @@ public class SuffixArray
         private int[] m_lcp;
         private C5.HashDictionary<char, int> m_chainHeadsDict = new HashDictionary<char, int>(new CharComparer());
         private List<Chain> m_chainStack = new List<Chain>();
-        ArrayList<Chain> m_subChains = new ArrayList<Chain>();
+        private ArrayList<Chain> m_subChains = new ArrayList<Chain>();
         private int m_nextRank = 1;
         private string m_str;
-        //private List<int> m_currentChain = new List<int>();
 
         public int Length
         {
@@ -116,8 +59,20 @@ public string Str
             get { return m_str; }
         }
 
-        public SuffixArray(string str) : this(str, true) {}
+        /// 
+        /// <summary>
+        /// Build a suffix array from string str
+        /// </summary>
+        /// <param name="str">A string for which to build a suffix array with LCP information</param>
+        /// <param name="buildLcps">Also build LCP array</param>
+        public SuffixArray(string str) : this(str, true) { }
 
+        /// 
+        /// <summary>
+        /// Build a suffix array from string str
+        /// </summary>
+        /// <param name="str">A string for which to build a suffix array</param>
+        /// <param name="buildLcps">Also calculate LCP information</param>
         public SuffixArray(string str, bool buildLcps) 
         {
             m_str = str;
@@ -134,11 +89,47 @@ public SuffixArray(string str, bool buildLcps)
                 BuildLcpArray();
         }
 
-        /// <summary>
-        /// Link all suffixes that have the same first character
-        /// </summary>
+        /// 
+        /// <summary>Find the index of a substring </summary>
+        /// <param name="substr">Substring to look for</param>
+        /// <returns>First index in the original string. -1 if not found</returns>
+        public int IndexOf(string substr)
+        {
+            int l = 0;
+            int r = m_sa.Length;
+            int m = -1;
+
+            if ((substr == null) || (substr.Length == 0))
+            {
+                return -1;
+            }
+
+            // Binary search for substring
+            while (r > l)
+            {
+                m = (l + r) / 2;
+                if (m_str.Substring(m_sa[m]).CompareTo(substr) < 0)
+                {
+                    l = m + 1;
+                }
+                else
+                {
+                    r = m;
+                }
+            }
+            if ((l == r) && (l < m_str.Length) && (m_str.Substring(m_sa[l]).StartsWith(substr)))
+            {
+                return m_sa[l];
+            }
+            else
+            {
+                return -1;
+            }
+        }
+
         private void FormInitialChains()
         {
+            // Link all suffixes that have the same first character
             FindInitialChains();
             SortAndPushSubchains();
         }
@@ -205,61 +196,59 @@ private void RefineChains(Chain chain)
             m_subChains.Clear();
             while (chain.head != EOC)
             {
-                // TODO - refactor this to get rid of the side effect of changing m_isa
                 int nextIndex = m_isa[chain.head];
-                UpdateSubChains(chain);
+                if (chain.head + chain.length > m_str.Length - 1)
+                {
+                    RankSuffix(chain.head);
+                }
+                else
+                {
+                    ExtendChain(chain);
+                }
                 chain.head = nextIndex;
             }
-            // Keep stack lexically sorted
+            // Keep stack sorted
             SortAndPushSubchains();
         }
 
-        private void UpdateSubChains(Chain chain)
+        private void ExtendChain(Chain chain)
         {
-            if (chain.head + chain.length > m_str.Length - 1)
+            char sym = m_str[chain.head + chain.length];
+            if (m_chainHeadsDict.Contains(sym))
             {
-                RankSuffix(chain.head);
+                // Continuation of an existing chain, this is the leftmost
+                // occurence currently known (others may come up later)
+                m_isa[m_chainHeadsDict[sym]] = chain.head;
+                m_isa[chain.head] = EOC;
             }
             else
             {
-                char sym = m_str[chain.head + chain.length];
-                if (m_chainHeadsDict.Contains(sym))
-                {
-                    // Continuation of a known chain, this is the leftmost
-                    // occurence currently known (others may come up later)
-                    m_isa[m_chainHeadsDict[sym]] = chain.head;
-                    m_isa[chain.head] = EOC;
-                }
-                else
-                {
-                    // This is the beginning of a new subchain
-                    m_isa[chain.head] = EOC;
-                    Chain newChain = new Chain(m_str);
-                    newChain.head = chain.head;
-                    newChain.length = chain.length + 1;
-                    m_subChains.Add(newChain);
-                }
-                // Save index in case we find a continuation of this chain
-                m_chainHeadsDict[sym] = chain.head;
+                // This is the beginning of a new subchain
+                m_isa[chain.head] = EOC;
+                Chain newChain = new Chain(m_str);
+                newChain.head = chain.head;
+                newChain.length = chain.length + 1;
+                m_subChains.Add(newChain);
             }
+            // Save index in case we find a continuation of this chain
+            m_chainHeadsDict[sym] = chain.head;
         }
 
         private void RefineChainWithInductionSorting(Chain chain)
         {
-            // TODO - refactor m_chainHeadsDict and m_subChains into a subchains class, remove class members and pass a 
-            // variable instead (get rid of global state)
+            // TODO - refactor/beautify some
+            ArrayList<SuffixRank> notedSuffixes = new ArrayList<SuffixRank>();
             m_chainHeadsDict.Clear();
             m_subChains.Clear();
 
-            // TODO - and refactor notedSuffixes too
-            ArrayList<SuffixRank> notedSuffixes = new ArrayList<SuffixRank>();
-
             while (chain.head != EOC)
             {
                 int nextIndex = m_isa[chain.head];
-                // TODO - refactor 
                 if (chain.head + chain.length > m_str.Length - 1)
                 {
+                    // If this substring reaches end of string it cannot be extended.
+                    // At this point it's the first in lexicographic order so it's safe
+                    // to just go ahead and rank it.
                     RankSuffix(chain.head);
                 }
                 else if (m_isa[chain.head + chain.length] < 0)
@@ -271,11 +260,11 @@ private void RefineChainWithInductionSorting(Chain chain)
                 }
                 else
                 {
-                    UpdateSubChains(chain);
+                    ExtendChain(chain);
                 }
                 chain.head = nextIndex;
             }
-            // Keep stack lexically sorted
+            // Keep stack sorted
             SortAndPushSubchains();
             SortAndRankNotedSuffixes(notedSuffixes);
         }
@@ -318,39 +307,66 @@ private int CalcLcp(int i, int j)
             return lcp;
         }
 
-        public int IndexOf(string substr)
+    }
+
+    #region HelperClasses
+    [Serializable]
+    internal class Chain : IComparable<Chain>
+    {
+        public int head;
+        public int length;
+        private string m_str;
+
+        public Chain(string str)
         {
-            int l = 0;
-            int r = m_sa.Length;
-            int m = -1;
+            m_str = str;
+        }
 
-            if ((substr == null) || (substr.Length == 0))
-            {
-                return -1;
-            }
+        public int CompareTo(Chain other)
+        {
+            return m_str.Substring(head, length).CompareTo(m_str.Substring(other.head, other.length));
+        }
 
-            // Binary search for substring
-            while (r > l)
-            {
-                m = (l + r) / 2;
-                if (m_str.Substring(m_sa[m]).CompareTo(substr) < 0)
-                {
-                    l = m + 1;
-                }
-                else
-                {
-                    r = m;
-                }
-            }
-            if ((l == r) && (l < m_str.Length) && (m_str.Substring(m_sa[l]).StartsWith(substr)))
-            {
-                return m_sa[l];
-            }
-            else
-            {
-                return -1;
-            }
+        public override string ToString()
+        {
+            return m_str.Substring(head, length);
+        }
+    }
+
+    [Serializable]
+    internal class CharComparer : System.Collections.Generic.EqualityComparer<char>
+    {
+        public override bool Equals(char x, char y)
+        {
+            return x.Equals(y);
+        }
+
+        public override int GetHashCode(char obj)
+        {
+            return obj.GetHashCode();
+        }
+    }
+
+    [Serializable]
+    internal struct SuffixRank
+    {
+        public int head;
+        public int rank;
+    }
+
+    [Serializable]
+    internal class SuffixRankComparer : IComparer<SuffixRank>
+    {
+        public bool Equals(SuffixRank x, SuffixRank y)
+        {
+            return x.rank.Equals(y.rank);
+        }
+
+        public int Compare(SuffixRank x, SuffixRank y)
+        {
+            return x.rank.CompareTo(y.rank);
         }
     }
+    #endregion
 }