lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From nightowl...@apache.org
Subject [3/6] lucenenet git commit: Lucene.Net.Analysis.Compound refactor: member accessibility and documentation comments
Date Thu, 02 Feb 2017 20:15:55 GMT
Lucene.Net.Analysis.Compound refactor: member accessibility and documentation comments


Project: http://git-wip-us.apache.org/repos/asf/lucenenet/repo
Commit: http://git-wip-us.apache.org/repos/asf/lucenenet/commit/6dc3ac1f
Tree: http://git-wip-us.apache.org/repos/asf/lucenenet/tree/6dc3ac1f
Diff: http://git-wip-us.apache.org/repos/asf/lucenenet/diff/6dc3ac1f

Branch: refs/heads/api-work
Commit: 6dc3ac1fad1053c2f65856ddd15243dd57e5045b
Parents: 487927c
Author: Shad Storhaug <shad@shadstorhaug.com>
Authored: Fri Feb 3 01:12:23 2017 +0700
Committer: Shad Storhaug <shad@shadstorhaug.com>
Committed: Fri Feb 3 01:13:43 2017 +0700

----------------------------------------------------------------------
 .../Compound/CompoundWordTokenFilterBase.cs     | 45 +++++----
 .../DictionaryCompoundWordTokenFilter.cs        | 25 +++--
 .../DictionaryCompoundWordTokenFilterFactory.cs |  9 +-
 .../Analysis/Compound/Hyphenation/ByteVector.cs |  2 +-
 .../Analysis/Compound/Hyphenation/CharVector.cs |  9 +-
 .../Analysis/Compound/Hyphenation/Hyphen.cs     |  2 +-
 .../Compound/Hyphenation/Hyphenation.cs         |  9 +-
 .../Compound/Hyphenation/HyphenationTree.cs     | 66 +++++++------
 .../Compound/Hyphenation/PatternConsumer.cs     | 49 +++++-----
 .../Compound/Hyphenation/PatternParser.cs       | 97 +++++++++++++++-----
 .../Compound/Hyphenation/TernaryTree.cs         | 62 ++++++-------
 .../HyphenationCompoundWordTokenFilter.cs       | 36 ++++----
 ...HyphenationCompoundWordTokenFilterFactory.cs | 39 ++++----
 13 files changed, 251 insertions(+), 199 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/lucenenet/blob/6dc3ac1f/src/Lucene.Net.Analysis.Common/Analysis/Compound/CompoundWordTokenFilterBase.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Compound/CompoundWordTokenFilterBase.cs b/src/Lucene.Net.Analysis.Common/Analysis/Compound/CompoundWordTokenFilterBase.cs
index 705ce55..0d42753 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Compound/CompoundWordTokenFilterBase.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Compound/CompoundWordTokenFilterBase.cs
@@ -26,18 +26,15 @@ namespace Lucene.Net.Analysis.Compound
 
     /// <summary>
     /// Base class for decomposition token filters.
-    /// <para>
-    /// 
-    /// <a name="version"></a>
-    /// You must specify the required <seealso cref="LuceneVersion"/> compatibility when creating
-    /// CompoundWordTokenFilterBase:
-    /// <ul>
-    /// <li>As of 3.1, CompoundWordTokenFilterBase correctly handles Unicode 4.0
-    /// supplementary characters in strings and char arrays provided as compound word
-    /// dictionaries.
-    /// <li>As of 4.4, <seealso cref="CompoundWordTokenFilterBase"/> doesn't update offsets.
-    /// </ul>
-    /// </para>
+    /// <para/>
+    /// You must specify the required <see cref="LuceneVersion"/> compatibility when creating
+    /// <see cref="CompoundWordTokenFilterBase"/>:
+    /// <list type="bullet">
+    ///     <item>As of 3.1, CompoundWordTokenFilterBase correctly handles Unicode 4.0
+    ///     supplementary characters in strings and char arrays provided as compound word
+    ///     dictionaries.</item>
+    ///     <item>As of 4.4, <see cref="CompoundWordTokenFilterBase"/> doesn't update offsets.</item>
+    /// </list>
     /// </summary>
     public abstract class CompoundWordTokenFilterBase : TokenFilter
     {
@@ -56,16 +53,16 @@ namespace Lucene.Net.Analysis.Compound
         /// </summary>
         public const int DEFAULT_MAX_SUBWORD_SIZE = 15;
 
-        protected internal readonly LuceneVersion m_matchVersion;
-        protected internal readonly CharArraySet m_dictionary;
-        protected internal readonly LinkedList<CompoundToken> m_tokens;
-        protected internal readonly int m_minWordSize;
-        protected internal readonly int m_minSubwordSize;
-        protected internal readonly int m_maxSubwordSize;
-        protected internal readonly bool m_onlyLongestMatch;
+        protected readonly LuceneVersion m_matchVersion;
+        protected readonly CharArraySet m_dictionary;
+        protected readonly LinkedList<CompoundToken> m_tokens;
+        protected readonly int m_minWordSize;
+        protected readonly int m_minSubwordSize;
+        protected readonly int m_maxSubwordSize;
+        protected readonly bool m_onlyLongestMatch;
 
-        protected internal readonly ICharTermAttribute m_termAtt;
-        protected internal readonly IOffsetAttribute m_offsetAtt;
+        protected readonly ICharTermAttribute m_termAtt;
+        protected readonly IOffsetAttribute m_offsetAtt;
         private readonly IPositionIncrementAttribute posIncAtt;
 
         private AttributeSource.State current;
@@ -144,7 +141,7 @@ namespace Lucene.Net.Analysis.Compound
         }
 
         /// <summary>
-        /// Decomposes the current <seealso cref="#termAtt"/> and places <seealso cref="CompoundToken"/> instances in the <seealso cref="#tokens"/> list.
+        /// Decomposes the current <see cref="m_termAtt"/> and places <see cref="CompoundToken"/> instances in the <see cref="m_tokens"/> list.
         /// The original token may not be placed in the list, as it is automatically passed through this filter.
         /// </summary>
         protected abstract void Decompose();
@@ -159,7 +156,7 @@ namespace Lucene.Net.Analysis.Compound
         /// <summary>
         /// Helper class to hold decompounded token information
         /// </summary>
-        protected internal class CompoundToken
+        protected class CompoundToken
         {
             private readonly ICharSequence txt;
             private readonly int startOffset, endOffset;
@@ -180,7 +177,7 @@ namespace Lucene.Net.Analysis.Compound
             }
 
             /// <summary>
-            /// Construct the compound token based on a slice of the current <seealso cref="CompoundWordTokenFilterBase#termAtt"/>. </summary>
+            /// Construct the compound token based on a slice of the current <see cref="CompoundWordTokenFilterBase.m_termAtt"/>. </summary>
             public CompoundToken(CompoundWordTokenFilterBase outerInstance, int offset, int length)
             {
                 this.txt = outerInstance.m_termAtt.SubSequence(offset, offset + length);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/6dc3ac1f/src/Lucene.Net.Analysis.Common/Analysis/Compound/DictionaryCompoundWordTokenFilter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Compound/DictionaryCompoundWordTokenFilter.cs b/src/Lucene.Net.Analysis.Common/Analysis/Compound/DictionaryCompoundWordTokenFilter.cs
index 7221927..12ce070 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Compound/DictionaryCompoundWordTokenFilter.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Compound/DictionaryCompoundWordTokenFilter.cs
@@ -21,27 +21,26 @@ namespace Lucene.Net.Analysis.Compound
      */
 
     /// <summary>
-    /// A <seealso cref="TokenFilter"/> that decomposes compound words found in many Germanic languages.
+    /// A <see cref="TokenFilter"/> that decomposes compound words found in many Germanic languages.
     /// <para>
     /// "Donaudampfschiff" becomes Donau, dampf, schiff so that you can find
     /// "Donaudampfschiff" even when you only enter "schiff". 
     ///  It uses a brute-force algorithm to achieve this.
     /// </para>
     /// <para>
-    /// You must specify the required <seealso cref="LuceneVersion"/> compatibility when creating
-    /// CompoundWordTokenFilterBase:
-    /// <ul>
-    /// <li>As of 3.1, CompoundWordTokenFilterBase correctly handles Unicode 4.0
-    /// supplementary characters in strings and char arrays provided as compound word
-    /// dictionaries.
-    /// </ul>
+    /// You must specify the required <see cref="LuceneVersion"/> compatibility when creating
+    /// <see cref="CompoundWordTokenFilterBase"/>:
+    /// <list type="bullet">
+    ///     <item>As of 3.1, CompoundWordTokenFilterBase correctly handles Unicode 4.0
+    ///     supplementary characters in strings and char arrays provided as compound word
+    ///     dictionaries.</item>
+    /// </list>
     /// </para>
     /// </summary>
     public class DictionaryCompoundWordTokenFilter : CompoundWordTokenFilterBase
     {
-
         /// <summary>
-        /// Creates a new <seealso cref="DictionaryCompoundWordTokenFilter"/>
+        /// Creates a new <see cref="DictionaryCompoundWordTokenFilter"/>
         /// </summary>
         /// <param name="matchVersion">
         ///          Lucene version to enable correct Unicode 4.0 behavior in the
@@ -49,7 +48,7 @@ namespace Lucene.Net.Analysis.Compound
         ///          href="CompoundWordTokenFilterBase.html#version"
         ///          >CompoundWordTokenFilterBase</a> for details. </param>
         /// <param name="input">
-        ///          the <seealso cref="TokenStream"/> to process </param>
+        ///          the <see cref="TokenStream"/> to process </param>
         /// <param name="dictionary">
         ///          the word dictionary to match against. </param>
         public DictionaryCompoundWordTokenFilter(LuceneVersion matchVersion, TokenStream input, CharArraySet dictionary)
@@ -62,7 +61,7 @@ namespace Lucene.Net.Analysis.Compound
         }
 
         /// <summary>
-        /// Creates a new <seealso cref="DictionaryCompoundWordTokenFilter"/>
+        /// Creates a new <see cref="DictionaryCompoundWordTokenFilter"/>
         /// </summary>
         /// <param name="matchVersion">
         ///          Lucene version to enable correct Unicode 4.0 behavior in the
@@ -70,7 +69,7 @@ namespace Lucene.Net.Analysis.Compound
         ///          href="CompoundWordTokenFilterBase.html#version"
         ///          >CompoundWordTokenFilterBase</a> for details. </param>
         /// <param name="input">
-        ///          the <seealso cref="TokenStream"/> to process </param>
+        ///          the <see cref="TokenStream"/> to process </param>
         /// <param name="dictionary">
         ///          the word dictionary to match against. </param>
         /// <param name="minWordSize">

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/6dc3ac1f/src/Lucene.Net.Analysis.Common/Analysis/Compound/DictionaryCompoundWordTokenFilterFactory.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Compound/DictionaryCompoundWordTokenFilterFactory.cs b/src/Lucene.Net.Analysis.Common/Analysis/Compound/DictionaryCompoundWordTokenFilterFactory.cs
index a44eb19..4dcb266 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Compound/DictionaryCompoundWordTokenFilterFactory.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Compound/DictionaryCompoundWordTokenFilterFactory.cs
@@ -21,15 +21,16 @@ namespace Lucene.Net.Analysis.Compound
      */
 
     /// <summary>
-    /// Factory for <seealso cref="DictionaryCompoundWordTokenFilter"/>. 
-    /// <pre class="prettyprint">
+    /// Factory for <see cref="DictionaryCompoundWordTokenFilter"/>. 
+    /// <code>
     /// &lt;fieldType name="text_dictcomp" class="solr.TextField" positionIncrementGap="100"&gt;
     ///   &lt;analyzer&gt;
     ///     &lt;tokenizer class="solr.WhitespaceTokenizerFactory"/&gt;
     ///     &lt;filter class="solr.DictionaryCompoundWordTokenFilterFactory" dictionary="dictionary.txt"
     ///         minWordSize="5" minSubwordSize="2" maxSubwordSize="15" onlyLongestMatch="true"/&gt;
     ///   &lt;/analyzer&gt;
-    /// &lt;/fieldType&gt;</pre>
+    /// &lt;/fieldType&gt;
+    /// </code>
     /// </summary>
     public class DictionaryCompoundWordTokenFilterFactory : TokenFilterFactory, IResourceLoaderAware
     {
@@ -41,7 +42,7 @@ namespace Lucene.Net.Analysis.Compound
         private readonly bool onlyLongestMatch;
 
         /// <summary>
-        /// Creates a new DictionaryCompoundWordTokenFilterFactory </summary>
+        /// Creates a new <see cref="DictionaryCompoundWordTokenFilterFactory"/> </summary>
         public DictionaryCompoundWordTokenFilterFactory(IDictionary<string, string> args)
             : base(args)
         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/6dc3ac1f/src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/ByteVector.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/ByteVector.cs b/src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/ByteVector.cs
index 206a7c4..4df2e3a 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/ByteVector.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/ByteVector.cs
@@ -27,7 +27,6 @@ namespace Lucene.Net.Analysis.Compound.Hyphenation
     /// </summary>
     public class ByteVector
     {
-
         /// <summary>
         /// Capacity increment size
         /// </summary>
@@ -122,6 +121,7 @@ namespace Lucene.Net.Analysis.Compound.Hyphenation
             get { return array.Length; }
         }
 
+        // LUCENENET NOTE: Not needed (replaced with this[])
         //public virtual void Put(int index, sbyte val)
         //{
         //    array[index] = val;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/6dc3ac1f/src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/CharVector.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/CharVector.cs b/src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/CharVector.cs
index c9f513b..2e67343 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/CharVector.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/CharVector.cs
@@ -99,7 +99,7 @@ namespace Lucene.Net.Analysis.Compound.Hyphenation
 
         public virtual object Clone()
         {
-            CharVector cv = new CharVector(array, blockSize);
+            CharVector cv = new CharVector((char[])array.Clone(), blockSize);
             cv.n = this.n;
             return cv;
         }
@@ -117,8 +117,6 @@ namespace Lucene.Net.Analysis.Compound.Hyphenation
         /// <summary>
         /// LUCENENET indexer for .NET
         /// </summary>
-        /// <param name="index"></param>
-        /// <returns></returns>
         public virtual char this[int index]
         {
             get { return array[index]; }
@@ -128,9 +126,9 @@ namespace Lucene.Net.Analysis.Compound.Hyphenation
         /// <summary>
         /// return number of items in array
         /// </summary>
-        public virtual int Length()
+        public virtual int Length
         {
-            return n;
+            get { return n; }
         }
 
         /// <summary>
@@ -141,6 +139,7 @@ namespace Lucene.Net.Analysis.Compound.Hyphenation
             get { return array.Length; }
         }
 
+        // LUCENENET NOTE: Not needed (replaced with this[])
         //public virtual void Put(int index, char val)
         //{
         //    array[index] = val;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/6dc3ac1f/src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/Hyphen.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/Hyphen.cs b/src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/Hyphen.cs
index 08168a4..0fb57d9 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/Hyphen.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/Hyphen.cs
@@ -28,7 +28,7 @@ namespace Lucene.Net.Analysis.Compound.Hyphenation
     /// cases in some languages where words change spelling if they're split across
     /// lines, like german's 'backen' which hyphenates 'bak-ken'. BTW, this comes
     /// from TeX.
-    /// 
+    /// <para/>
     /// This class has been taken from the Apache FOP project (http://xmlgraphics.apache.org/fop/). They have been slightly modified. 
     /// </summary>
     public class Hyphen

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/6dc3ac1f/src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/Hyphenation.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/Hyphenation.cs b/src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/Hyphenation.cs
index ec33fd0..1cdb7d4 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/Hyphenation.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/Hyphenation.cs
@@ -22,29 +22,28 @@ namespace Lucene.Net.Analysis.Compound.Hyphenation
 
     /// <summary>
     /// This class represents a hyphenated word.
-    /// 
+    /// <para/>
     /// This class has been taken from the Apache FOP project (http://xmlgraphics.apache.org/fop/). They have been slightly modified.
     /// </summary>
     public class Hyphenation
     {
-
         private readonly int[] hyphenPoints;
 
         /// <summary>
-        /// rawWord as made of alternating strings and <seealso cref="Hyphen"/> instances
+        /// rawWord as made of alternating strings and <see cref="Hyphen"/> instances
         /// </summary>
         internal Hyphenation(int[] points)
         {
             hyphenPoints = points;
         }
 
-        /// <returns> the number of hyphenation points in the word </returns>
+        /// <summary> the number of hyphenation points in the word </summary>
         public virtual int Length
         {
             get { return hyphenPoints.Length; }
         }
 
-        /// <returns> the hyphenation points </returns>
+        /// <summary> the hyphenation points </summary>
         [WritableArray]
         [SuppressMessage("Microsoft.Performance", "CA1819", Justification = "Lucene's design requires some writable array properties")]
         public virtual int[] HyphenationPoints

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/6dc3ac1f/src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/HyphenationTree.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/HyphenationTree.cs b/src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/HyphenationTree.cs
index 7e1420d..c4dfe8b 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/HyphenationTree.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/HyphenationTree.cs
@@ -27,7 +27,7 @@ namespace Lucene.Net.Analysis.Compound.Hyphenation
     /// <summary>
 	/// This tree structure stores the hyphenation patterns in an efficient way for
 	/// fast lookup. It provides the provides the method to hyphenate a word.
-	/// 
+	/// <para/>
 	/// This class has been taken from the Apache FOP project (http://xmlgraphics.apache.org/fop/). They have been slightly modified. 
 	/// </summary>
 	public class HyphenationTree : TernaryTree, IPatternConsumer
@@ -35,17 +35,17 @@ namespace Lucene.Net.Analysis.Compound.Hyphenation
         /// <summary>
         /// value space: stores the interletter values
         /// </summary>
-        protected internal ByteVector m_vspace;
+        protected ByteVector m_vspace;
 
         /// <summary>
         /// This map stores hyphenation exceptions
         /// </summary>
-        protected internal IDictionary<string, IList<object>> m_stoplist;
+        protected IDictionary<string, IList<object>> m_stoplist;
 
         /// <summary>
         /// This map stores the character classes
         /// </summary>
-        protected internal TernaryTree m_classmap;
+        protected TernaryTree m_classmap;
 
         /// <summary>
         /// Temporary map to store interletter values on pattern loading.
@@ -71,7 +71,7 @@ namespace Lucene.Net.Analysis.Compound.Hyphenation
         /// <param name="values"> a string of digits from '0' to '9' representing the
         ///        interletter values. </param>
         /// <returns> the index into the vspace array where the packed values are stored. </returns>
-        protected internal virtual int PackValues(string values)
+        protected virtual int PackValues(string values)
         {
             int i, n = values.Length;
             int m = (n & 1) == 1 ? (n >> 1) + 2 : (n >> 1) + 1;
@@ -94,7 +94,7 @@ namespace Lucene.Net.Analysis.Compound.Hyphenation
             return offset;
         }
 
-        protected internal virtual string UnpackValues(int k)
+        protected virtual string UnpackValues(int k)
         {
             StringBuilder buf = new StringBuilder();
             byte v = m_vspace[k++];
@@ -128,6 +128,7 @@ namespace Lucene.Net.Analysis.Compound.Hyphenation
         /// Read hyphenation patterns from an XML file.
         /// </summary>
         /// <param name="f"> the filename </param>
+        /// <param name="encoding">The character encoding to use</param>
         /// <exception cref="IOException"> In case the parsing fails </exception>
         public virtual void LoadPatterns(string filename, Encoding encoding)
         {
@@ -138,7 +139,7 @@ namespace Lucene.Net.Analysis.Compound.Hyphenation
         /// <summary>
         /// Read hyphenation patterns from an XML file.
         /// </summary>
-        /// <param name="f"> the filename </param>
+        /// <param name="f"> a <see cref="FileInfo"/> object representing the file </param>
         /// <exception cref="IOException"> In case the parsing fails </exception>
         public virtual void LoadPatterns(FileInfo f)
         {
@@ -148,7 +149,8 @@ namespace Lucene.Net.Analysis.Compound.Hyphenation
         /// <summary>
         /// Read hyphenation patterns from an XML file.
         /// </summary>
-        /// <param name="f"> the filename </param>
+        /// <param name="f"> a <see cref="FileInfo"/> object representing the file </param>
+        /// <param name="encoding">The character encoding to use</param>
         /// <exception cref="IOException"> In case the parsing fails </exception>
         public virtual void LoadPatterns(FileInfo f, Encoding encoding)
         {
@@ -159,7 +161,7 @@ namespace Lucene.Net.Analysis.Compound.Hyphenation
         /// <summary>
         /// Read hyphenation patterns from an XML file.
         /// </summary>
-        /// <param name="source"> the InputSource for the file </param>
+        /// <param name="source"> <see cref="Stream"/> input source for the file </param>
         /// <exception cref="IOException"> In case the parsing fails </exception>
         public virtual void LoadPatterns(Stream source)
         {
@@ -169,7 +171,8 @@ namespace Lucene.Net.Analysis.Compound.Hyphenation
         /// <summary>
         /// Read hyphenation patterns from an XML file.
         /// </summary>
-        /// <param name="source"> the InputSource for the file </param>
+        /// <param name="source"> <see cref="Stream"/> input source for the file </param>
+        /// <param name="encoding">The character encoding to use</param>
         /// <exception cref="IOException"> In case the parsing fails </exception>
         public virtual void LoadPatterns(Stream source, Encoding encoding)
         {
@@ -190,6 +193,11 @@ namespace Lucene.Net.Analysis.Compound.Hyphenation
             }
         }
 
+        /// <summary>
+        /// Read hyphenation patterns from an <see cref="XmlReader"/>.
+        /// </summary>
+        /// <param name="source"> <see cref="XmlReader"/> input source for the file </param>
+        /// <exception cref="IOException"> In case the parsing fails </exception>
         public virtual void LoadPatterns(XmlReader source)
         {
             PatternParser pp = new PatternParser(this);
@@ -220,7 +228,7 @@ namespace Lucene.Net.Analysis.Compound.Hyphenation
         /// <summary>
         /// String compare, returns 0 if equal or t is a substring of s
         /// </summary>
-        protected internal virtual int HStrCmp(char[] s, int si, char[] t, int ti)
+        protected virtual int HStrCmp(char[] s, int si, char[] t, int ti)
         {
             for (; s[si] == t[ti]; si++, ti++)
             {
@@ -236,7 +244,7 @@ namespace Lucene.Net.Analysis.Compound.Hyphenation
             return s[si] - t[ti];
         }
 
-        protected internal virtual byte[] GetValues(int k)
+        protected virtual byte[] GetValues(int k)
         {
             StringBuilder buf = new StringBuilder();
             byte v = m_vspace[k++];
@@ -267,9 +275,10 @@ namespace Lucene.Net.Analysis.Compound.Hyphenation
         /// interletter values. In other words, it does something like:
         /// </para>
         /// <code>
-        /// for(i=0; i&lt;patterns.length; i++) {
-        /// if ( word.substring(index).startsWidth(patterns[i]) )
-        /// update_interletter_values(patterns[i]);
+        /// for (i=0; i&lt;patterns.Length; i++) 
+        /// {
+        ///     if (word.Substring(index).StartsWith(patterns[i]))
+        ///         update_interletter_values(patterns[i]);
         /// }
         /// </code>
         /// <para>
@@ -286,7 +295,7 @@ namespace Lucene.Net.Analysis.Compound.Hyphenation
         /// <param name="word"> null terminated word to match </param>
         /// <param name="index"> start index from word </param>
         /// <param name="il"> interletter values array to update </param>
-        protected internal virtual void SearchPatterns(char[] word, int index, byte[] il)
+        protected virtual void SearchPatterns(char[] word, int index, byte[] il)
         {
             byte[] values;
             int i = index;
@@ -365,14 +374,14 @@ namespace Lucene.Net.Analysis.Compound.Hyphenation
         }
 
         /// <summary>
-        /// Hyphenate word and return a Hyphenation object.
+        /// Hyphenate word and return a <see cref="Hyphenation"/> object.
         /// </summary>
         /// <param name="word"> the word to be hyphenated </param>
         /// <param name="remainCharCount"> Minimum number of characters allowed before the
         ///        hyphenation point. </param>
         /// <param name="pushCharCount"> Minimum number of characters allowed after the
         ///        hyphenation point. </param>
-        /// <returns> a <seealso cref="Hyphenation Hyphenation"/> object representing the
+        /// <returns> a <see cref="Hyphenation"/> object representing the
         ///         hyphenated word or null if word is not hyphenated. </returns>
         public virtual Hyphenation Hyphenate(string word, int remainCharCount, int pushCharCount)
         {
@@ -380,7 +389,12 @@ namespace Lucene.Net.Analysis.Compound.Hyphenation
             return Hyphenate(w, 0, w.Length, remainCharCount, pushCharCount);
         }
 
+
+
         /// <summary>
+        /// Hyphenate word and return an array of hyphenation points.
+        /// </summary>
+        /// <remarks>
         /// w = "****nnllllllnnn*****", where n is a non-letter, l is a letter, all n
         /// may be absent, the first n is at offset, the first l is at offset +
         /// iIgnoreAtBeginning; word = ".llllll.'\0'***", where all l in w are copied
@@ -392,11 +406,7 @@ namespace Lucene.Net.Analysis.Compound.Hyphenation
         /// index(word) - 1 (see first loop). It follows that: index(w) - index(word) =
         /// offset - 1 + iIgnoreAtBeginning index(w) = letterindex(word) + offset +
         /// iIgnoreAtBeginning
-        /// </summary>
-
-        /// <summary>
-        /// Hyphenate word and return an array of hyphenation points.
-        /// </summary>
+        /// </remarks>
         /// <param name="w"> char array that contains the word </param>
         /// <param name="offset"> Offset to first character in word </param>
         /// <param name="len"> Length of word </param>
@@ -404,7 +414,7 @@ namespace Lucene.Net.Analysis.Compound.Hyphenation
         ///        hyphenation point. </param>
         /// <param name="pushCharCount"> Minimum number of characters allowed after the
         ///        hyphenation point. </param>
-        /// <returns> a <seealso cref="Hyphenation Hyphenation"/> object representing the
+        /// <returns> a <see cref="Hyphenation"/> object representing the
         ///         hyphenated word or null if word is not hyphenated. </returns>
         public virtual Hyphenation Hyphenate(char[] w, int offset, int len, int remainCharCount, int pushCharCount)
         {
@@ -522,7 +532,7 @@ namespace Lucene.Net.Analysis.Compound.Hyphenation
 
         /// <summary>
         /// Add a character class to the tree. It is used by
-        /// <seealso cref="PatternParser PatternParser"/> as callback to add character classes.
+        /// <see cref="PatternParser"/> as callback to add character classes.
         /// Character classes define the valid word characters for hyphenation. If a
         /// word contains a character not defined in any of the classes, it is not
         /// hyphenated. It also defines a way to normalize the characters in order to
@@ -547,12 +557,12 @@ namespace Lucene.Net.Analysis.Compound.Hyphenation
 
         /// <summary>
         /// Add an exception to the tree. It is used by
-        /// <seealso cref="PatternParser PatternParser"/> class as callback to store the
+        /// <see cref="PatternParser"/> class as callback to store the
         /// hyphenation exceptions.
         /// </summary>
         /// <param name="word"> normalized word </param>
         /// <param name="hyphenatedword"> a vector of alternating strings and
-        ///        <seealso cref="Hyphen hyphen"/> objects. </param>
+        ///        <see cref="Hyphen"/> objects. </param>
         public virtual void AddException(string word, IList<object> hyphenatedword)
         {
             m_stoplist[word] = hyphenatedword;
@@ -560,7 +570,7 @@ namespace Lucene.Net.Analysis.Compound.Hyphenation
 
         /// <summary>
         /// Add a pattern to the tree. Mainly, to be used by
-        /// <seealso cref="PatternParser PatternParser"/> class as callback to add a pattern to
+        /// <see cref="PatternParser"/> class as callback to add a pattern to
         /// the tree.
         /// </summary>
         /// <param name="pattern"> the hyphenation pattern </param>

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/6dc3ac1f/src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/PatternConsumer.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/PatternConsumer.cs b/src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/PatternConsumer.cs
index 4929892..1d92db5 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/PatternConsumer.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/PatternConsumer.cs
@@ -22,33 +22,32 @@ namespace Lucene.Net.Analysis.Compound.Hyphenation
     /// <summary>
     /// This interface is used to connect the XML pattern file parser to the
     /// hyphenation tree.
-    /// 
-    /// This class has been taken from the Apache FOP project (http://xmlgraphics.apache.org/fop/). They have been slightly modified.
+    /// <para/>
+    /// This interface has been taken from the Apache FOP project (http://xmlgraphics.apache.org/fop/). They have been slightly modified.
     /// </summary>
     public interface IPatternConsumer
-	{
+    {
+        /// <summary>
+        /// Add a character class. A character class defines characters that are
+        /// considered equivalent for the purpose of hyphenation (e.g. "aA"). It
+        /// usually means to ignore case.
+        /// </summary>
+        /// <param name="chargroup"> character group </param>
+        void AddClass(string chargroup);
 
-	  /// <summary>
-	  /// Add a character class. A character class defines characters that are
-	  /// considered equivalent for the purpose of hyphenation (e.g. "aA"). It
-	  /// usually means to ignore case.
-	  /// </summary>
-	  /// <param name="chargroup"> character group </param>
-	  void AddClass(string chargroup);
+        /// <summary>
+        /// Add a hyphenation exception. An exception replaces the result obtained by
+        /// the algorithm for cases for which this fails or the user wants to provide
+        /// his own hyphenation. A hyphenatedword is a vector of alternating String's
+        /// and <see cref="Hyphen"/> instances
+        /// </summary>
+        void AddException(string word, IList<object> hyphenatedword);
 
-	  /// <summary>
-	  /// Add a hyphenation exception. An exception replaces the result obtained by
-	  /// the algorithm for cases for which this fails or the user wants to provide
-	  /// his own hyphenation. A hyphenatedword is a vector of alternating String's
-	  /// and <seealso cref="Hyphen"/> instances
-	  /// </summary>
-	  void AddException(string word, IList<object> hyphenatedword);
-
-	  /// <summary>
-	  /// Add hyphenation patterns.
-	  /// </summary>
-	  /// <param name="pattern"> the pattern </param>
-	  /// <param name="values"> interletter values expressed as a string of digit characters. </param>
-	  void AddPattern(string pattern, string values);
-	}
+        /// <summary>
+        /// Add hyphenation patterns.
+        /// </summary>
+        /// <param name="pattern"> the pattern </param>
+        /// <param name="values"> interletter values expressed as a string of digit characters. </param>
+        void AddPattern(string pattern, string values);
+    }
 }
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/6dc3ac1f/src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/PatternParser.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/PatternParser.cs b/src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/PatternParser.cs
index 8849cff..9b9f226 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/PatternParser.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/PatternParser.cs
@@ -27,7 +27,7 @@ namespace Lucene.Net.Analysis.Compound.Hyphenation
     /// <summary>
     /// A XMLReader document handler to read and parse hyphenation patterns from a XML
     /// file.
-    /// 
+    /// <para/>
     /// LUCENENET: This class has been refactored from its Java counterpart to use XmlReader rather
     /// than a SAX parser.
     /// </summary>
@@ -59,7 +59,8 @@ namespace Lucene.Net.Analysis.Compound.Hyphenation
             hyphenChar = '-'; // default
         }
 
-        public PatternParser(IPatternConsumer consumer) : this()
+        public PatternParser(IPatternConsumer consumer) 
+            : this()
         {
             this.consumer = consumer;
         }
@@ -79,14 +80,26 @@ namespace Lucene.Net.Analysis.Compound.Hyphenation
         /// <summary>
         /// Parses a hyphenation pattern file.
         /// </summary>
-        /// <param name="filename"> the filename </param>
+        /// <param name="path">The complete file path to be read.</param>
         /// <exception cref="IOException"> In case of an exception while parsing </exception>
-        public virtual void Parse(string filename)
+        public virtual void Parse(string path)
+        {
+            // LUCENENET TODO: Create overloads that allow XmlReaderSettings to be passed in.
+            Parse(path, Encoding.UTF8);
+        }
+
+        /// <summary>
+        /// Parses a hyphenation pattern file.
+        /// </summary>
+        /// <param name="path">The complete file path to be read.</param>
+        /// <param name="encoding">The character encoding to use</param>
+        /// <exception cref="IOException"> In case of an exception while parsing </exception>
+        public virtual void Parse(string path, Encoding encoding)
         {
             var xmlReaderSettings = GetXmlReaderSettings();
 
             // LUCENENET TODO: Create overloads that allow XmlReaderSettings to be passed in.
-            using (var src = XmlReader.Create(filename, xmlReaderSettings))
+            using (var src = XmlReader.Create(new StreamReader(path, encoding), xmlReaderSettings))
             {
                 Parse(src);
             }
@@ -95,7 +108,8 @@ namespace Lucene.Net.Analysis.Compound.Hyphenation
         /// <summary>
         /// Parses a hyphenation pattern file.
         /// </summary>
-        /// <param name="file"> the pattern file </param>
+        /// <param name="file">  a <see cref="FileInfo"/> object representing the file  </param>
+        /// <exception cref="IOException"> In case of an exception while parsing </exception>
         public virtual void Parse(FileInfo file)
         {
             Parse(file, Encoding.UTF8);
@@ -104,7 +118,9 @@ namespace Lucene.Net.Analysis.Compound.Hyphenation
         /// <summary>
         /// Parses a hyphenation pattern file.
         /// </summary>
-        /// <param name="file"> the pattern file </param>
+        /// <param name="file">  a <see cref="FileInfo"/> object representing the file </param>
+        /// <param name="encoding">The character encoding to use</param>
+        /// <exception cref="IOException"> In case of an exception while parsing </exception>
         public virtual void Parse(FileInfo file, Encoding encoding)
         {
             var xmlReaderSettings = GetXmlReaderSettings();
@@ -118,7 +134,14 @@ namespace Lucene.Net.Analysis.Compound.Hyphenation
         /// <summary>
         /// Parses a hyphenation pattern file.
         /// </summary>
-        /// <param name="file"> the pattern file </param>
+        /// <param name="xmlStream">
+        /// The stream containing the XML data.
+        /// <para/>
+        /// The <see cref="PatternParser"/> scans the first bytes of the stream looking for a byte order mark 
+        /// or other sign of encoding. When encoding is determined, the encoding is used to continue reading 
+        /// the stream, and processing continues parsing the input as a stream of (Unicode) characters.
+        /// </param>
+        /// <exception cref="IOException"> In case of an exception while parsing </exception>
         public virtual void Parse(Stream xmlStream)
         {
             var xmlReaderSettings = GetXmlReaderSettings();
@@ -132,7 +155,7 @@ namespace Lucene.Net.Analysis.Compound.Hyphenation
         /// <summary>
         /// Parses a hyphenation pattern file.
         /// </summary>
-        /// <param name="source"> the InputSource for the file </param>
+        /// <param name="source"> <see cref="XmlReader"/> input source for the file </param>
         /// <exception cref="IOException"> In case of an exception while parsing </exception>
         public virtual void Parse(XmlReader source)
         {
@@ -209,7 +232,7 @@ namespace Lucene.Net.Analysis.Compound.Hyphenation
             return result;
         }
 
-        protected internal virtual string ReadToken(StringBuilder chars)
+        protected virtual string ReadToken(StringBuilder chars)
         {
             string word;
             bool space = false;
@@ -266,7 +289,7 @@ namespace Lucene.Net.Analysis.Compound.Hyphenation
             return null;
         }
 
-        protected internal static string GetPattern(string word)
+        protected static string GetPattern(string word)
         {
             StringBuilder pat = new StringBuilder();
             int len = word.Length;
@@ -280,7 +303,7 @@ namespace Lucene.Net.Analysis.Compound.Hyphenation
             return pat.ToString();
         }
 
-        protected internal virtual IList<object> NormalizeException<T1>(IList<T1> ex)
+        protected virtual IList<object> NormalizeException<T1>(IList<T1> ex)
         {
             List<object> res = new List<object>();
             for (int i = 0; i < ex.Count; i++)
@@ -321,7 +344,7 @@ namespace Lucene.Net.Analysis.Compound.Hyphenation
             return res;
         }
 
-        protected internal virtual string GetExceptionWord<T1>(IList<T1> ex)
+        protected virtual string GetExceptionWord<T1>(IList<T1> ex)
         {
             StringBuilder res = new StringBuilder();
             for (int i = 0; i < ex.Count; i++)
@@ -342,7 +365,7 @@ namespace Lucene.Net.Analysis.Compound.Hyphenation
             return res.ToString();
         }
 
-        protected internal static string GetInterletterValues(string pat)
+        protected static string GetInterletterValues(string pat)
         {
             StringBuilder il = new StringBuilder();
             string word = pat + "a"; // add dummy letter to serve as sentinel
@@ -388,9 +411,19 @@ namespace Lucene.Net.Analysis.Compound.Hyphenation
         // ContentHandler methods
         //
 
-        /// <seealso cref= org.xml.sax.ContentHandler#startElement(java.lang.String,
-        ///      java.lang.String, java.lang.String, org.xml.sax.Attributes) </seealso>
-        public void StartElement(string uri, string local, string raw, IDictionary<string, string> attrs)
+        /// <summary>
+        /// Receive notification of the beginning of an element.
+        /// <para/>
+        /// The Parser will invoke this method at the beginning of every element in the XML document; 
+        /// there will be a corresponding <see cref="EndElement"/> event for every <see cref="StartElement"/> event 
+        /// (even when the element is empty). All of the element's content will be reported, 
+        /// in order, before the corresponding endElement event.
+        /// </summary>
+        /// <param name="uri">the Namespace URI, or the empty string if the element has no Namespace URI or if Namespace processing is not being performed</param>
+        /// <param name="local">the local name (without prefix), or the empty string if Namespace processing is not being performed</param>
+        /// <param name="raw"></param>
+        /// <param name="attrs"> the attributes attached to the element. If there are no attributes, it shall be an empty Attributes object. The value of this object after startElement returns is undefined</param>
+        public virtual void StartElement(string uri, string local, string raw, IDictionary<string, string> attrs)
         {
             if (local.Equals("hyphen-char"))
             {
@@ -425,9 +458,17 @@ namespace Lucene.Net.Analysis.Compound.Hyphenation
             token.Length = 0;
         }
 
-        /// <seealso cref= org.xml.sax.ContentHandler#endElement(java.lang.String,
-        ///      java.lang.String, java.lang.String) </seealso>
-        public void EndElement(string uri, string local, string raw)
+        /// <summary>
+        /// Receive notification of the end of an element.
+        /// <para/>
+        /// The parser will invoke this method at the end of every element in the XML document; 
+        /// there will be a corresponding <see cref="StartElement"/> event for every 
+        /// <see cref="EndElement"/> event (even when the element is empty).
+        /// </summary>
+        /// <param name="uri">the Namespace URI, or the empty string if the element has no Namespace URI or if Namespace processing is not being performed</param>
+        /// <param name="local">the local name (without prefix), or the empty string if Namespace processing is not being performed</param>
+        /// <param name="raw"></param>
+        public virtual void EndElement(string uri, string local, string raw)
         {
             if (token.Length > 0)
             {
@@ -464,8 +505,20 @@ namespace Lucene.Net.Analysis.Compound.Hyphenation
             }
         }
 
-        /// <seealso cref= org.xml.sax.ContentHandler#characters(char[], int, int) </seealso>
-        public void Characters(char[] ch, int start, int length)
+        /// <summary>
+        /// Receive notification of character data.
+        /// <para/>
+        /// The Parser will call this method to report each chunk of character data. Parsers may 
+        /// return all contiguous character data in a single chunk, or they may split it into 
+        /// several chunks; however, all of the characters in any single event must come from 
+        /// the same external entity so that the Locator provides useful information.
+        /// <para/>
+        /// The application must not attempt to read from the array outside of the specified range.
+        /// </summary>
+        /// <param name="ch"></param>
+        /// <param name="start"></param>
+        /// <param name="length"></param>
+        public virtual void Characters(char[] ch, int start, int length)
         {
             StringBuilder chars = new StringBuilder(length);
             chars.Append(ch, start, length);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/6dc3ac1f/src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/TernaryTree.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/TernaryTree.cs b/src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/TernaryTree.cs
index 87e9d19..82feaec 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/TernaryTree.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/TernaryTree.cs
@@ -70,65 +70,63 @@ namespace Lucene.Net.Analysis.Compound.Hyphenation
         : ICloneable
 #endif
     {
-        /// <summary>
-        /// We use 4 arrays to represent a node. I guess I should have created a proper
-        /// node class, but somehow Knuth's pascal code made me forget we now have a
-        /// portable language with virtual memory management and automatic garbage
-        /// collection! And now is kind of late, furthermore, if it ain't broken, don't
-        /// fix it.
-        /// </summary>
+        // We use 4 arrays to represent a node.I guess I should have created a proper
+        // node class, but somehow Knuth's pascal code made me forget we now have a
+        // portable language with virtual memory management and automatic garbage
+        // collection! And now is kind of late, furthermore, if it ain't broken, don't
+        // fix it.
 
         /// <summary>
         /// Pointer to low branch and to rest of the key when it is stored directly in
         /// this node, we don't have unions in java!
         /// </summary>
-        protected internal char[] m_lo;
+        protected char[] m_lo;
 
         /// <summary>
         /// Pointer to high branch.
         /// </summary>
-        protected internal char[] m_hi;
+        protected char[] m_hi;
 
         /// <summary>
         /// Pointer to equal branch and to data when this node is a string terminator.
         /// </summary>
-        protected internal char[] m_eq;
+        protected char[] m_eq;
 
         /// <summary>
-        /// <P>
+        /// <para>
         /// The character stored in this node: splitchar. Two special values are
         /// reserved:
-        /// </P>
-        /// <ul>
-        /// <li>0x0000 as string terminator</li>
-        /// <li>0xFFFF to indicate that the branch starting at this node is compressed</li>
-        /// </ul>
+        /// </para>
+        /// <list type="bullet">
+        ///     <item>0x0000 as string terminator</item>
+        ///     <item>0xFFFF to indicate that the branch starting at this node is compressed</item>
+        /// </list>
         /// <para>
         /// This shouldn't be a problem if we give the usual semantics to strings since
         /// 0xFFFF is guaranteed not to be an Unicode character.
         /// </para>
         /// </summary>
-        protected internal char[] m_sc;
+        protected char[] m_sc;
 
         /// <summary>
         /// This vector holds the trailing of the keys when the branch is compressed.
         /// </summary>
-        protected internal CharVector m_kv;
+        protected CharVector m_kv;
 
-        protected internal char m_root;
+        protected char m_root;
 
-        protected internal char m_freenode;
+        protected char m_freenode;
 
-        protected internal int m_length; // number of items in tree
+        protected int m_length; // number of items in tree
 
-        protected internal const int BLOCK_SIZE = 2048; // allocation size for arrays
+        protected const int BLOCK_SIZE = 2048; // allocation size for arrays
 
         internal TernaryTree()
         {
             Init();
         }
 
-        protected internal virtual void Init()
+        protected virtual void Init()
         {
             m_root = (char)0;
             m_freenode = (char)1;
@@ -408,7 +406,7 @@ namespace Lucene.Net.Analysis.Compound.Hyphenation
             get { return m_length; }
         }
 
-        public object Clone()
+        public virtual object Clone()
         {
             TernaryTree t = new TernaryTree();
             t.m_lo = (char[])this.m_lo.Clone();
@@ -428,7 +426,7 @@ namespace Lucene.Net.Analysis.Compound.Hyphenation
         /// upper halves, and so on in order to get a balanced tree. The array of keys
         /// is assumed to be sorted in ascending order.
         /// </summary>
-        protected internal virtual void InsertBalanced(string[] k, char[] v, int offset, int n)
+        protected virtual void InsertBalanced(string[] k, char[] v, int offset, int n)
         {
             int m;
             if (n < 1)
@@ -555,7 +553,7 @@ namespace Lucene.Net.Analysis.Compound.Hyphenation
             /// </summary>
             private string curkey;
 
-            internal class Item
+            private class Item
 #if FEATURE_CLONEABLE
                 : ICloneable
 #endif
@@ -585,12 +583,12 @@ namespace Lucene.Net.Analysis.Compound.Hyphenation
             /// <summary>
             /// Node stack
             /// </summary>
-            internal Stack<Item> ns;
+            private Stack<Item> ns;
 
             /// <summary>
-            /// key stack implemented with a StringBuilder
+            /// key stack implemented with a <see cref="StringBuilder"/>
             /// </summary>
-            internal StringBuilder ks;
+            private StringBuilder ks;
 
             private bool isInitialized = false;
 
@@ -626,7 +624,7 @@ namespace Lucene.Net.Analysis.Compound.Hyphenation
             /// <summary>
             /// traverse upwards
             /// </summary>
-            internal virtual int Up()
+            private int Up()
             {
                 Item i = new Item();
                 int res = 0;
@@ -690,7 +688,7 @@ namespace Lucene.Net.Analysis.Compound.Hyphenation
             /// <summary>
             /// traverse the tree to find next key
             /// </summary>
-            internal virtual int Run()
+            private int Run()
             {
                 if (cur == -1)
                 {
@@ -794,7 +792,7 @@ namespace Lucene.Net.Analysis.Compound.Hyphenation
             @out.WriteLine("Number of keys = " + Convert.ToString(m_length));
             @out.WriteLine("Node count = " + Convert.ToString(m_freenode));
             // System.out.println("Array length = " + Integer.toString(eq.length));
-            @out.WriteLine("Key Array length = " + Convert.ToString(m_kv.Length()));
+            @out.WriteLine("Key Array length = " + Convert.ToString(m_kv.Length));
 
             /*
              * for(int i=0; i<kv.length(); i++) if ( kv.get(i) != 0 )

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/6dc3ac1f/src/Lucene.Net.Analysis.Common/Analysis/Compound/HyphenationCompoundWordTokenFilter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Compound/HyphenationCompoundWordTokenFilter.cs b/src/Lucene.Net.Analysis.Common/Analysis/Compound/HyphenationCompoundWordTokenFilter.cs
index 4608c01..83a1a46 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Compound/HyphenationCompoundWordTokenFilter.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Compound/HyphenationCompoundWordTokenFilter.cs
@@ -24,20 +24,20 @@ namespace Lucene.Net.Analysis.Compound
      */
 
     /// <summary>
-    /// A <seealso cref="TokenFilter"/> that decomposes compound words found in many Germanic languages.
+    /// A <see cref="TokenFilter"/> that decomposes compound words found in many Germanic languages.
     /// <para>
     /// "Donaudampfschiff" becomes Donau, dampf, schiff so that you can find
     /// "Donaudampfschiff" even when you only enter "schiff". It uses a hyphenation
     /// grammar and a word dictionary to achieve this.
     /// </para>
     /// <para>
-    /// You must specify the required <seealso cref="LuceneVersion"/> compatibility when creating
-    /// CompoundWordTokenFilterBase:
-    /// <ul>
-    /// <li>As of 3.1, CompoundWordTokenFilterBase correctly handles Unicode 4.0
-    /// supplementary characters in strings and char arrays provided as compound word
-    /// dictionaries.
-    /// </ul>
+    /// You must specify the required <see cref="LuceneVersion"/> compatibility when creating
+    /// <see cref="CompoundWordTokenFilterBase"/>:
+    /// <list type="bullet">
+    ///     <item>As of 3.1, CompoundWordTokenFilterBase correctly handles Unicode 4.0
+    ///     supplementary characters in strings and char arrays provided as compound word
+    ///     dictionaries.</item>
+    /// </list>
     /// </para>
     /// </summary>
     public class HyphenationCompoundWordTokenFilter : CompoundWordTokenFilterBase
@@ -45,7 +45,7 @@ namespace Lucene.Net.Analysis.Compound
         private readonly HyphenationTree hyphenator;
 
         /// <summary>
-        /// Creates a new <seealso cref="HyphenationCompoundWordTokenFilter"/> instance. 
+        /// Creates a new <see cref="HyphenationCompoundWordTokenFilter"/> instance. 
         /// </summary>
         /// <param name="matchVersion">
         ///          Lucene version to enable correct Unicode 4.0 behavior in the
@@ -66,7 +66,7 @@ namespace Lucene.Net.Analysis.Compound
         }
 
         /// <summary>
-        /// Creates a new <seealso cref="HyphenationCompoundWordTokenFilter"/> instance.
+        /// Creates a new <see cref="HyphenationCompoundWordTokenFilter"/> instance.
         /// </summary>
         /// <param name="matchVersion">
         ///          Lucene version to enable correct Unicode 4.0 behavior in the
@@ -93,16 +93,13 @@ namespace Lucene.Net.Analysis.Compound
             : base(matchVersion, input, dictionary, minWordSize, minSubwordSize, maxSubwordSize, 
                   onlyLongestMatch)
         {
-
             this.hyphenator = hyphenator;
         }
 
         /// <summary>
-        /// Create a HyphenationCompoundWordTokenFilter with no dictionary.
+        /// Create a <see cref="HyphenationCompoundWordTokenFilter"/> with no dictionary.
         /// <para>
-        /// Calls {@link #HyphenationCompoundWordTokenFilter(Version, TokenStream, HyphenationTree, CharArraySet, int, int, int, boolean)
-        /// HyphenationCompoundWordTokenFilter(matchVersion, input, hyphenator,
-        /// null, minWordSize, minSubwordSize, maxSubwordSize }
+        /// Calls <see cref="HyphenationCompoundWordTokenFilter.HyphenationCompoundWordTokenFilter(LuceneVersion, TokenStream, HyphenationTree, CharArraySet, int, int, int, bool)"/>
         /// </para>
         /// </summary>
         public HyphenationCompoundWordTokenFilter(LuceneVersion matchVersion, TokenStream input, 
@@ -114,11 +111,9 @@ namespace Lucene.Net.Analysis.Compound
         }
 
         /// <summary>
-        /// Create a HyphenationCompoundWordTokenFilter with no dictionary.
+        /// Create a <see cref="HyphenationCompoundWordTokenFilter"/> with no dictionary.
         /// <para>
-        /// Calls {@link #HyphenationCompoundWordTokenFilter(Version, TokenStream, HyphenationTree, int, int, int) 
-        /// HyphenationCompoundWordTokenFilter(matchVersion, input, hyphenator, 
-        /// DEFAULT_MIN_WORD_SIZE, DEFAULT_MIN_SUBWORD_SIZE, DEFAULT_MAX_SUBWORD_SIZE }
+        /// Calls <see cref="HyphenationCompoundWordTokenFilter.HyphenationCompoundWordTokenFilter(LuceneVersion, TokenStream, HyphenationTree, int, int, int)"/>
         /// </para>
         /// </summary>
         public HyphenationCompoundWordTokenFilter(LuceneVersion matchVersion, TokenStream input, 
@@ -143,6 +138,7 @@ namespace Lucene.Net.Analysis.Compound
         /// Create a hyphenator tree
         /// </summary>
         /// <param name="hyphenationFilename"> the filename of the XML grammar to load </param>
+        /// <param name="encoding">The character encoding to use</param>
         /// <returns> An object representing the hyphenation patterns </returns>
         /// <exception cref="IOException"> If there is a low-level I/O error. </exception>
         public static HyphenationTree GetHyphenationTree(string hyphenationFilename, Encoding encoding)
@@ -165,6 +161,7 @@ namespace Lucene.Net.Analysis.Compound
         /// Create a hyphenator tree
         /// </summary>
         /// <param name="hyphenationFile"> the file of the XML grammar to load </param>
+        /// <param name="encoding">The character encoding to use</param>
         /// <returns> An object representing the hyphenation patterns </returns>
         /// <exception cref="IOException"> If there is a low-level I/O error. </exception>
         public static HyphenationTree GetHyphenationTree(FileInfo hyphenationFile, Encoding encoding)
@@ -187,6 +184,7 @@ namespace Lucene.Net.Analysis.Compound
         /// Create a hyphenator tree
         /// </summary>
         /// <param name="hyphenationSource"> the InputSource pointing to the XML grammar </param>
+        /// <param name="encoding">The character encoding to use</param>
         /// <returns> An object representing the hyphenation patterns </returns>
         /// <exception cref="IOException"> If there is a low-level I/O error. </exception>
         public static HyphenationTree GetHyphenationTree(Stream hyphenationSource, Encoding encoding)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/6dc3ac1f/src/Lucene.Net.Analysis.Common/Analysis/Compound/HyphenationCompoundWordTokenFilterFactory.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Compound/HyphenationCompoundWordTokenFilterFactory.cs b/src/Lucene.Net.Analysis.Common/Analysis/Compound/HyphenationCompoundWordTokenFilterFactory.cs
index 5dfec4a..75a7917 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Compound/HyphenationCompoundWordTokenFilterFactory.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Compound/HyphenationCompoundWordTokenFilterFactory.cs
@@ -25,34 +25,33 @@ namespace Lucene.Net.Analysis.Compound
 	 */
 
     /// <summary>
-    /// Factory for <seealso cref="HyphenationCompoundWordTokenFilter"/>.
-    /// <para>
+    /// Factory for <see cref="HyphenationCompoundWordTokenFilter"/>.
+    /// <para/>
     /// This factory accepts the following parameters:
-    /// <ul>
-    ///  <li><code>hyphenator</code> (mandatory): path to the FOP xml hyphenation pattern. 
-    ///  See <a href="http://offo.sourceforge.net/hyphenation/">http://offo.sourceforge.net/hyphenation/</a>.
-    ///  <li><code>encoding</code> (optional): encoding of the xml hyphenation file. defaults to UTF-8.
-    ///  <li><code>dictionary</code> (optional): dictionary of words. defaults to no dictionary.
-    ///  <li><code>minWordSize</code> (optional): minimal word length that gets decomposed. defaults to 5.
-    ///  <li><code>minSubwordSize</code> (optional): minimum length of subwords. defaults to 2.
-    ///  <li><code>maxSubwordSize</code> (optional): maximum length of subwords. defaults to 15.
-    ///  <li><code>onlyLongestMatch</code> (optional): if true, adds only the longest matching subword 
-    ///    to the stream. defaults to false.
-    /// </ul>
-    /// </para>
+    /// <list type="bullet">
+    ///     <item><code>hyphenator</code> (mandatory): path to the FOP xml hyphenation pattern. 
+    ///     See <a href="http://offo.sourceforge.net/hyphenation/">http://offo.sourceforge.net/hyphenation/</a>.</item>
+    ///     <item><code>encoding</code> (optional): encoding of the xml hyphenation file. defaults to UTF-8.</item>
+    ///     <item><code>dictionary</code> (optional): dictionary of words. defaults to no dictionary.</item>
+    ///     <item><code>minWordSize</code> (optional): minimal word length that gets decomposed. defaults to 5.</item>
+    ///     <item><code>minSubwordSize</code> (optional): minimum length of subwords. defaults to 2.</item>
+    ///     <item><code>maxSubwordSize</code> (optional): maximum length of subwords. defaults to 15.</item>
+    ///     <item><code>onlyLongestMatch</code> (optional): if true, adds only the longest matching subword 
+    ///     to the stream. defaults to false.</item>
+    /// </list>
     /// <para>
-    /// <pre class="prettyprint">
+    /// <code>
     /// &lt;fieldType name="text_hyphncomp" class="solr.TextField" positionIncrementGap="100"&gt;
     ///   &lt;analyzer&gt;
     ///     &lt;tokenizer class="solr.WhitespaceTokenizerFactory"/&gt;
     ///     &lt;filter class="solr.HyphenationCompoundWordTokenFilterFactory" hyphenator="hyphenator.xml" encoding="UTF-8"
     ///         dictionary="dictionary.txt" minWordSize="5" minSubwordSize="2" maxSubwordSize="15" onlyLongestMatch="false"/&gt;
     ///   &lt;/analyzer&gt;
-    /// &lt;/fieldType&gt;</pre>
-    /// 
+    /// &lt;/fieldType&gt;
+    /// </code>
     /// </para>
     /// </summary>
-    /// <seealso cref= HyphenationCompoundWordTokenFilter </seealso>
+    /// <seealso cref="HyphenationCompoundWordTokenFilter"/>
     public class HyphenationCompoundWordTokenFilterFactory : TokenFilterFactory, IResourceLoaderAware
     {
         private CharArraySet dictionary;
@@ -66,13 +65,13 @@ namespace Lucene.Net.Analysis.Compound
         private readonly bool onlyLongestMatch;
 
         /// <summary>
-        /// Creates a new HyphenationCompoundWordTokenFilterFactory </summary>
+        /// Creates a new <see cref="HyphenationCompoundWordTokenFilterFactory"/> </summary>
         public HyphenationCompoundWordTokenFilterFactory(IDictionary<string, string> args) : base(args)
         {
             AssureMatchVersion();
             dictFile = Get(args, "dictionary");
             encoding = Get(args, "encoding");
-            hypFile = Require(args, "hyphenator"); // LUCENENET TODO: Not sure what to do with this
+            hypFile = Require(args, "hyphenator");
             minWordSize = GetInt(args, "minWordSize", CompoundWordTokenFilterBase.DEFAULT_MIN_WORD_SIZE);
             minSubwordSize = GetInt(args, "minSubwordSize", CompoundWordTokenFilterBase.DEFAULT_MIN_SUBWORD_SIZE);
             maxSubwordSize = GetInt(args, "maxSubwordSize", CompoundWordTokenFilterBase.DEFAULT_MAX_SUBWORD_SIZE);


Mime
View raw message