lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From nightowl...@apache.org
Subject [06/39] lucenenet git commit: Lucene.Net.Analysis.Standard refactor: member accessibility and documentation comments
Date Sat, 04 Feb 2017 20:32:25 GMT
Lucene.Net.Analysis.Standard 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/ab69b431
Tree: http://git-wip-us.apache.org/repos/asf/lucenenet/tree/ab69b431
Diff: http://git-wip-us.apache.org/repos/asf/lucenenet/diff/ab69b431

Branch: refs/heads/api-work
Commit: ab69b43179733001dbb84836732c0f9671021de8
Parents: 6b01385
Author: Shad Storhaug <shad@shadstorhaug.com>
Authored: Sat Feb 4 12:18:16 2017 +0700
Committer: Shad Storhaug <shad@shadstorhaug.com>
Committed: Sat Feb 4 12:18:16 2017 +0700

----------------------------------------------------------------------
 .../Analysis/Standard/ClassicAnalyzer.cs        |  45 ++-
 .../Analysis/Standard/ClassicFilter.cs          |   7 +-
 .../Analysis/Standard/ClassicFilterFactory.cs   |   7 +-
 .../Analysis/Standard/ClassicTokenizer.cs       |  41 ++-
 .../Standard/ClassicTokenizerFactory.cs         |   2 +-
 .../Analysis/Standard/ClassicTokenizerImpl.cs   |  39 ++-
 .../Analysis/Standard/StandardAnalyzer.cs       |  46 ++-
 .../Analysis/Standard/StandardFilterFactory.cs  |   2 +-
 .../Analysis/Standard/StandardTokenizer.cs      |  66 ++--
 .../Standard/StandardTokenizerFactory.cs        |   2 +-
 .../Analysis/Standard/StandardTokenizerImpl.cs  |  48 ++-
 .../Standard/StandardTokenizerInterface.cs      |  22 +-
 .../Standard/Std31/StandardTokenizerImpl31.cs   | 297 ++++++++---------
 .../Std31/UAX29URLEmailTokenizerImpl31.cs       |  75 ++---
 .../Standard/Std34/StandardTokenizerImpl34.cs   | 302 +++++++++---------
 .../Std34/UAX29URLEmailTokenizerImpl34.cs       | 303 +++++++++---------
 .../Std36/UAX29URLEmailTokenizerImpl36.cs       | 299 +++++++++--------
 .../Standard/Std40/StandardTokenizerImpl40.cs   | 293 +++++++++--------
 .../Std40/UAX29URLEmailTokenizerImpl40.cs       | 295 +++++++++--------
 .../Analysis/Standard/UAX29URLEmailAnalyzer.cs  |  26 +-
 .../Analysis/Standard/UAX29URLEmailTokenizer.cs |  69 ++--
 .../Standard/UAX29URLEmailTokenizerFactory.cs   |   7 +-
 .../Standard/UAX29URLEmailTokenizerImpl.cs      | 319 +++++++++----------
 23 files changed, 1278 insertions(+), 1334 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/lucenenet/blob/ab69b431/src/Lucene.Net.Analysis.Common/Analysis/Standard/ClassicAnalyzer.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Standard/ClassicAnalyzer.cs b/src/Lucene.Net.Analysis.Common/Analysis/Standard/ClassicAnalyzer.cs
index 70aa887..888431b 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Standard/ClassicAnalyzer.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Standard/ClassicAnalyzer.cs
@@ -23,23 +23,22 @@ namespace Lucene.Net.Analysis.Standard
      */
 
     /// <summary>
-    /// Filters <see cref="ClassicTokenizer"/> with <see cref="ClassicFilter"/>, {@link
-    /// LowerCaseFilter} and <see cref="StopFilter"/>, using a list of
+    /// Filters <see cref="ClassicTokenizer"/> with <see cref="ClassicFilter"/>, 
+    /// <see cref="LowerCaseFilter"/> and <see cref="StopFilter"/>, using a list of
     /// English stop words.
     /// 
-    /// <a name="version"/>
     /// <para>You must specify the required <see cref="LuceneVersion"/>
-    /// compatibility when creating ClassicAnalyzer:
-    /// <ul>
-    ///   <li> As of 3.1, StopFilter correctly handles Unicode 4.0
-    ///         supplementary characters in stopwords
-    ///   <li> As of 2.9, StopFilter preserves position
-    ///        increments
-    ///   <li> As of 2.4, Tokens incorrectly identified as acronyms
-    ///        are corrected (see <a href="https://issues.apache.org/jira/browse/LUCENE-1068">LUCENE-1068</a>)
-    /// </ul>
+    /// compatibility when creating <see cref="ClassicAnalyzer"/>:
+    /// <list type="bullet">
+    ///     <item> As of 3.1, <see cref="StopFilter"/> correctly handles Unicode 4.0
+    ///         supplementary characters in stopwords</item>
+    ///     <item> As of 2.9, <see cref="StopFilter"/> preserves position
+    ///        increments</item>
+    ///     <item> As of 2.4, <see cref="Token"/>s incorrectly identified as acronyms
+    ///        are corrected (see <a href="https://issues.apache.org/jira/browse/LUCENE-1068">LUCENE-1068</a>)</item>
+    /// </list>
     /// 
-    /// ClassicAnalyzer was named StandardAnalyzer in Lucene versions prior to 3.1. 
+    /// <see cref="ClassicAnalyzer"/> was named <see cref="StandardAnalyzer"/> in Lucene versions prior to 3.1. 
     /// As of 3.1, <see cref="StandardAnalyzer"/> implements Unicode text segmentation,
     /// as specified by UAX#29.
     /// </para>
@@ -60,8 +59,7 @@ namespace Lucene.Net.Analysis.Standard
 
         /// <summary>
         /// Builds an analyzer with the given stop words. </summary>
-        /// <param name="matchVersion"> Lucene version to match See {@link
-        /// <a href="#version">above</a>} </param>
+        /// <param name="matchVersion"> Lucene compatibility version - See <see cref="ClassicAnalyzer"/> </param>
         /// <param name="stopWords"> stop words  </param>
         public ClassicAnalyzer(LuceneVersion matchVersion, CharArraySet stopWords)
             : base(matchVersion, stopWords)
@@ -69,10 +67,9 @@ namespace Lucene.Net.Analysis.Standard
         }
 
         /// <summary>
-        /// Builds an analyzer with the default stop words ({@link
-        /// #STOP_WORDS_SET}). </summary>
-        /// <param name="matchVersion"> Lucene version to match See {@link
-        /// <a href="#version">above</a>} </param>
+        /// Builds an analyzer with the default stop words (<see cref="STOP_WORDS_SET"/>).
+        /// </summary>
+        /// <param name="matchVersion"> Lucene compatibility version - See <see cref="ClassicAnalyzer"/> </param>
         public ClassicAnalyzer(LuceneVersion matchVersion)
             : this(matchVersion, STOP_WORDS_SET)
         {
@@ -80,17 +77,16 @@ namespace Lucene.Net.Analysis.Standard
 
         /// <summary>
         /// Builds an analyzer with the stop words from the given reader. </summary>
-        /// <seealso cref= WordlistLoader#getWordSet(TextReader, Version) </seealso>
-        /// <param name="matchVersion"> Lucene version to match See {@link
-        /// <a href="#version">above</a>} </param>
-        /// <param name="stopwords"> TextReader to read stop words from  </param>
+        /// <seealso cref="WordlistLoader.GetWordSet(TextReader, LuceneVersion)"/>
+        /// <param name="matchVersion"> Lucene compatibility version - See <see cref="ClassicAnalyzer"/> </param>
+        /// <param name="stopwords"> <see cref="TextReader"/> to read stop words from  </param>
         public ClassicAnalyzer(LuceneVersion matchVersion, TextReader stopwords)
             : this(matchVersion, LoadStopwordSet(stopwords, matchVersion))
         {
         }
 
         /// <summary>
-        /// Set maximum allowed token length.  If a token is seen
+        /// Gets or sets maximum allowed token length.  If a token is seen
         /// that exceeds this length then it is discarded.  This
         /// setting only takes effect the next time tokenStream or
         /// tokenStream is called.
@@ -101,7 +97,6 @@ namespace Lucene.Net.Analysis.Standard
             get { return maxTokenLength; }
         }
 
-
         protected override TokenStreamComponents CreateComponents(string fieldName, TextReader reader)
         {
             var src = new ClassicTokenizer(m_matchVersion, reader);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/ab69b431/src/Lucene.Net.Analysis.Common/Analysis/Standard/ClassicFilter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Standard/ClassicFilter.cs b/src/Lucene.Net.Analysis.Common/Analysis/Standard/ClassicFilter.cs
index c9bd8cf..6d629f8 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Standard/ClassicFilter.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Standard/ClassicFilter.cs
@@ -18,14 +18,13 @@ namespace Lucene.Net.Analysis.Standard
      * See the License for the specific language governing permissions and
      * limitations under the License.
      */
+
     /// <summary>
     /// Normalizes tokens extracted with <see cref="ClassicTokenizer"/>. </summary>
-
     public class ClassicFilter : TokenFilter
     {
-
         /// <summary>
-        /// Construct filtering <i>in</i>. </summary>
+        /// Construct filtering <paramref name="in"/>. </summary>
         public ClassicFilter(TokenStream @in)
             : base(@in)
         {
@@ -42,7 +41,7 @@ namespace Lucene.Net.Analysis.Standard
 
         /// <summary>
         /// Returns the next token in the stream, or null at EOS.
-        /// <para>Removes <tt>'s</tt> from the end of words.
+        /// <para>Removes <c>'s</c> from the end of words.
         /// </para>
         /// <para>Removes dots from acronyms.
         /// </para>

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/ab69b431/src/Lucene.Net.Analysis.Common/Analysis/Standard/ClassicFilterFactory.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Standard/ClassicFilterFactory.cs b/src/Lucene.Net.Analysis.Common/Analysis/Standard/ClassicFilterFactory.cs
index 80fac18..b15b460 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Standard/ClassicFilterFactory.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Standard/ClassicFilterFactory.cs
@@ -1,5 +1,5 @@
-using System.Collections.Generic;
-using Lucene.Net.Analysis.Util;
+using Lucene.Net.Analysis.Util;
+using System.Collections.Generic;
 
 namespace Lucene.Net.Analysis.Standard
 {
@@ -32,9 +32,8 @@ namespace Lucene.Net.Analysis.Standard
     /// </summary>
     public class ClassicFilterFactory : TokenFilterFactory
     {
-
         /// <summary>
-        /// Creates a new ClassicFilterFactory </summary>
+        /// Creates a new <see cref="ClassicFilterFactory"/> </summary>
         public ClassicFilterFactory(IDictionary<string, string> args)
             : base(args)
         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/ab69b431/src/Lucene.Net.Analysis.Common/Analysis/Standard/ClassicTokenizer.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Standard/ClassicTokenizer.cs b/src/Lucene.Net.Analysis.Common/Analysis/Standard/ClassicTokenizer.cs
index 415bdb7..6898ca6 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Standard/ClassicTokenizer.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Standard/ClassicTokenizer.cs
@@ -22,29 +22,28 @@ namespace Lucene.Net.Analysis.Standard
      */
 
     /// <summary>
-    /// A grammar-based tokenizer constructed with JFlex
+    /// A grammar-based tokenizer constructed with JFlex (and then ported to .NET)
     /// 
     /// <para> This should be a good tokenizer for most European-language documents:
     /// 
-    /// <ul>
-    ///   <li>Splits words at punctuation characters, removing punctuation. However, a 
-    ///     dot that's not followed by whitespace is considered part of a token.
-    ///   <li>Splits words at hyphens, unless there's a number in the token, in which case
-    ///     the whole token is interpreted as a product number and is not split.
-    ///   <li>Recognizes email addresses and internet hostnames as one token.
-    /// </ul>
+    /// <list type="bullet">
+    ///     <item>Splits words at punctuation characters, removing punctuation. However, a 
+    ///         dot that's not followed by whitespace is considered part of a token.</item>
+    ///     <item>Splits words at hyphens, unless there's a number in the token, in which case
+    ///         the whole token is interpreted as a product number and is not split.</item>
+    ///     <item>Recognizes email addresses and internet hostnames as one token.</item>
+    /// </list>
     /// 
     /// </para>
     /// <para>Many applications have specific tokenizer needs.  If this tokenizer does
     /// not suit your application, please consider copying this source code
     /// directory to your project and maintaining your own grammar-based tokenizer.
     /// 
-    /// ClassicTokenizer was named StandardTokenizer in Lucene versions prior to 3.1.
+    /// <see cref="ClassicTokenizer"/> was named <see cref="StandardTokenizer"/> in Lucene versions prior to 3.1.
     /// As of 3.1, <see cref="StandardTokenizer"/> implements Unicode text segmentation,
     /// as specified by UAX#29.
     /// </para>
     /// </summary>
-
     public sealed class ClassicTokenizer : Tokenizer
     {
         /// <summary>
@@ -64,7 +63,17 @@ namespace Lucene.Net.Analysis.Standard
 
         /// <summary>
         /// String token types that correspond to token type int constants </summary>
-        public static readonly string[] TOKEN_TYPES = new string[] { "<ALPHANUM>", "<APOSTROPHE>", "<ACRONYM>", "<COMPANY>", "<EMAIL>", "<HOST>", "<NUM>", "<CJ>", "<ACRONYM_DEP>" };
+        public static readonly string[] TOKEN_TYPES = new string[] {
+            "<ALPHANUM>",
+            "<APOSTROPHE>",
+            "<ACRONYM>",
+            "<COMPANY>",
+            "<EMAIL>",
+            "<HOST>",
+            "<NUM>",
+            "<CJ>",
+            "<ACRONYM_DEP>"
+        };
 
         private int skippedPositions;
 
@@ -93,8 +102,9 @@ namespace Lucene.Net.Analysis.Standard
 
         /// <summary>
         /// Creates a new instance of the <see cref="ClassicTokenizer"/>.  Attaches
-        /// the <code>input</code> to the newly created JFlex scanner.
+        /// the <paramref name="input"/> to the newly created JFlex scanner.
         /// </summary>
+        /// <param name="matchVersion"> lucene compatibility version </param>
         /// <param name="input"> The input reader
         /// 
         /// See http://issues.apache.org/jira/browse/LUCENE-1068 </param>
@@ -105,7 +115,7 @@ namespace Lucene.Net.Analysis.Standard
         }
 
         /// <summary>
-        /// Creates a new ClassicTokenizer with a given <see cref="org.apache.lucene.util.AttributeSource.AttributeFactory"/> 
+        /// Creates a new <see cref="ClassicTokenizer"/> with a given <see cref="AttributeSource.AttributeFactory"/> 
         /// </summary>
         public ClassicTokenizer(LuceneVersion matchVersion, AttributeFactory factory, Reader input)
             : base(factory, input)
@@ -128,12 +138,13 @@ namespace Lucene.Net.Analysis.Standard
         private IOffsetAttribute offsetAtt;
         private IPositionIncrementAttribute posIncrAtt;
         private ITypeAttribute typeAtt;
+        
         /*
          * (non-Javadoc)
          *
          * @see org.apache.lucene.analysis.TokenStream#next()
          */
-        public override bool IncrementToken()
+        public override sealed bool IncrementToken()
         {
             ClearAttributes();
             skippedPositions = 0;
@@ -175,7 +186,7 @@ namespace Lucene.Net.Analysis.Standard
             }
         }
 
-        public override void End()
+        public override sealed void End()
         {
             base.End();
             // set final offset

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/ab69b431/src/Lucene.Net.Analysis.Common/Analysis/Standard/ClassicTokenizerFactory.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Standard/ClassicTokenizerFactory.cs b/src/Lucene.Net.Analysis.Common/Analysis/Standard/ClassicTokenizerFactory.cs
index 079e824..0778eba 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Standard/ClassicTokenizerFactory.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Standard/ClassicTokenizerFactory.cs
@@ -36,7 +36,7 @@ namespace Lucene.Net.Analysis.Standard
         private readonly int maxTokenLength;
 
         /// <summary>
-        /// Creates a new ClassicTokenizerFactory </summary>
+        /// Creates a new <see cref="ClassicTokenizerFactory"/> </summary>
         public ClassicTokenizerFactory(IDictionary<string, string> args)
             : base(args)
         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/ab69b431/src/Lucene.Net.Analysis.Common/Analysis/Standard/ClassicTokenizerImpl.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Standard/ClassicTokenizerImpl.cs b/src/Lucene.Net.Analysis.Common/Analysis/Standard/ClassicTokenizerImpl.cs
index e7a35b0..7de5f9e 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Standard/ClassicTokenizerImpl.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Standard/ClassicTokenizerImpl.cs
@@ -29,12 +29,11 @@ namespace Lucene.Net.Analysis.Standard
 	
     */
     /// <summary>
-    /// This class implements the classic lucene StandardTokenizer up until 3.0 
+    /// This class implements the classic lucene <see cref="StandardTokenizer"/> up until 3.0 
     /// </summary>
 
     internal class ClassicTokenizerImpl : IStandardTokenizerInterface
     {
-
         /// <summary>
         /// This character denotes the end of file </summary>
         public static readonly int YYEOF = -1;
@@ -280,7 +279,7 @@ namespace Lucene.Net.Analysis.Standard
         };
 
         /// <summary>
-        /// ZZ_ATTRIBUTE[aState] contains the attributes of state <code>aState</code>
+        /// ZZ_ATTRIBUTE[aState] contains the attributes of state <c>aState</c>
         /// </summary>
         private static readonly int[] ZZ_ATTRIBUTE = ZzUnpackAttribute();
 
@@ -327,7 +326,7 @@ namespace Lucene.Net.Analysis.Standard
 
         /// <summary>
         /// this buffer contains the current text to be matched and is
-        ///    the source of the YyText() string 
+        ///    the source of the YyText string 
         /// </summary>
         private char[] zzBuffer = new char[ZZ_BUFFERSIZE];
 
@@ -340,7 +339,7 @@ namespace Lucene.Net.Analysis.Standard
         private int zzCurrentPos;
 
         /// <summary>
-        /// startRead marks the beginning of the YyText() string in the buffer </summary>
+        /// startRead marks the beginning of the YyText string in the buffer </summary>
         private int zzStartRead;
 
         /// <summary>
@@ -365,12 +364,12 @@ namespace Lucene.Net.Analysis.Standard
         private int yycolumn;
 
         /// <summary>
-        /// zzAtBOL == true <=> the scanner is currently at the beginning of a line
+        /// zzAtBOL == true &lt;=&gt; the scanner is currently at the beginning of a line
         /// </summary>
         private bool zzAtBOL = true;
 
         /// <summary>
-        /// zzAtEOF == true <=> the scanner is at the EOF </summary>
+        /// zzAtEOF == true &lt;=&gt; the scanner is at the EOF </summary>
         private bool zzAtEOF;
 
         /// <summary>
@@ -401,7 +400,7 @@ namespace Lucene.Net.Analysis.Standard
         }
 
         /// <summary>
-        /// Fills CharTermAttribute with the current token text.
+        /// Fills ICharTermAttribute with the current token text.
         /// </summary>
         public void GetText(ICharTermAttribute t)
         {
@@ -446,9 +445,9 @@ namespace Lucene.Net.Analysis.Standard
         /// <summary>
         /// Refills the input buffer.
         /// </summary>
-        /// <returns>      <code>false</code>, iff there was new input.
+        /// <returns>      <c>false</c>, iff there was new input.
         /// </returns>
-        /// <exception cref="java.io.IOException">  if any I/O-Error occurs </exception>
+        /// <exception cref="IOException">  if any I/O-Error occurs </exception>
         private bool ZzRefill()
         {
 
@@ -502,7 +501,7 @@ namespace Lucene.Net.Analysis.Standard
 
 
         /// <summary>
-        /// Closes the input stream.
+        /// Disposes the input stream.
         /// </summary>
         public void YyClose()
         {
@@ -519,11 +518,11 @@ namespace Lucene.Net.Analysis.Standard
         /// <summary>
         /// Resets the scanner to read from a new input stream.
         /// Does not close the old reader.
-        /// 
+        /// <para/>
         /// All internal variables are reset, the old input stream 
         /// <b>cannot</b> be reused (internal buffer is discarded and lost).
-        /// Lexical state is set to <tt>ZZ_INITIAL</tt>.
-        /// 
+        /// Lexical state is set to <see cref="YYINITIAL"/>.
+        /// <para/>
         /// Internal scan buffer is resized down to its initial length, if it has grown.
         /// </summary>
         /// <param name="reader">   the new input stream  </param>
@@ -576,10 +575,10 @@ namespace Lucene.Net.Analysis.Standard
         /// Returns the character at position <tt>pos</tt> from the 
         /// matched text. 
         /// 
-        /// It is equivalent to YyText().charAt(pos), but faster
+        /// It is equivalent to YyText[pos], but faster
         /// </summary>
         /// <param name="pos"> the position of the character to fetch. 
-        ///            A value from 0 to YyLength()-1.
+        ///            A value from 0 to YyLength-1.
         /// </param>
         /// <returns> the character at position pos </returns>
         public char YyCharAt(int pos)
@@ -599,13 +598,13 @@ namespace Lucene.Net.Analysis.Standard
 
         /// <summary>
         /// Reports an error that occured while scanning.
-        /// 
+        /// <para/>
         /// In a wellformed scanner (no or only correct usage of 
         /// YyPushBack(int) and a match-all fallback rule) this method 
         /// will only be called with things that "Can't Possibly Happen".
         /// If this method is called, something is seriously wrong
         /// (e.g. a JFlex bug producing a faulty scanner etc.).
-        /// 
+        /// <para/>
         /// Usual syntax/scanner level error handling should be done
         /// in error fallback rules.
         /// </summary>
@@ -632,7 +631,7 @@ namespace Lucene.Net.Analysis.Standard
         /// They will be read again by then next call of the scanning method
         /// </summary>
         /// <param name="number">  the number of characters to be read again.
-        ///                This number must not be greater than YyLength()! </param>
+        ///                This number must not be greater than YyLength! </param>
         public virtual void YyPushBack(int number)
         {
             if (number > YyLength)
@@ -649,7 +648,7 @@ namespace Lucene.Net.Analysis.Standard
         /// the end of input is encountered or an I/O-Error occurs.
         /// </summary>
         /// <returns>      the next token </returns>
-        /// <exception cref="java.io.IOException">  if any I/O-Error occurs </exception>
+        /// <exception cref="IOException">  if any I/O-Error occurs </exception>
         public virtual int GetNextToken()
         {
             int zzInput;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/ab69b431/src/Lucene.Net.Analysis.Common/Analysis/Standard/StandardAnalyzer.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Standard/StandardAnalyzer.cs b/src/Lucene.Net.Analysis.Common/Analysis/Standard/StandardAnalyzer.cs
index 5770b55..d7f8515 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Standard/StandardAnalyzer.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Standard/StandardAnalyzer.cs
@@ -23,31 +23,29 @@ namespace Lucene.Net.Analysis.Standard
      */
 
     /// <summary>
-    /// Filters <see cref="StandardTokenizer"/> with <see cref="StandardFilter"/>, {@link
-    /// LowerCaseFilter} and <see cref="StopFilter"/>, using a list of
+    /// Filters <see cref="StandardTokenizer"/> with <see cref="StandardFilter"/>, 
+    /// <see cref="LowerCaseFilter"/> and <see cref="StopFilter"/>, using a list of
     /// English stop words.
     /// 
-    /// <a name="version"/>
     /// <para>You must specify the required <see cref="LuceneVersion"/>
-    /// compatibility when creating StandardAnalyzer:
-    /// <ul>
-    ///   <li> As of 3.4, Hiragana and Han characters are no longer wrongly split
+    /// compatibility when creating <see cref="StandardAnalyzer"/>:
+    /// <list type="bullet">
+    ///   <item> As of 3.4, Hiragana and Han characters are no longer wrongly split
     ///        from their combining characters. If you use a previous version number,
-    ///        you get the exact broken behavior for backwards compatibility.
-    ///   <li> As of 3.1, StandardTokenizer implements Unicode text segmentation,
-    ///        and StopFilter correctly handles Unicode 4.0 supplementary characters
+    ///        you get the exact broken behavior for backwards compatibility.</item>
+    ///   <item> As of 3.1, <see cref="StandardTokenizer"/> implements Unicode text segmentation,
+    ///        and <see cref="StopFilter"/> correctly handles Unicode 4.0 supplementary characters
     ///        in stopwords.  <see cref="ClassicTokenizer"/> and <see cref="ClassicAnalyzer"/> 
-    ///        are the pre-3.1 implementations of StandardTokenizer and
-    ///        StandardAnalyzer.
-    ///   <li> As of 2.9, StopFilter preserves position increments
-    ///   <li> As of 2.4, Tokens incorrectly identified as acronyms
-    ///        are corrected (see <a href="https://issues.apache.org/jira/browse/LUCENE-1068">LUCENE-1068</a>)
-    /// </ul>
+    ///        are the pre-3.1 implementations of <see cref="StandardTokenizer"/> and
+    ///        <see cref="StandardAnalyzer"/>.</item>
+    ///   <item> As of 2.9, <see cref="StopFilter"/> preserves position increments</item>
+    ///   <item> As of 2.4, <see cref="Token"/>s incorrectly identified as acronyms
+    ///        are corrected (see <a href="https://issues.apache.org/jira/browse/LUCENE-1068">LUCENE-1068</a>)</item>
+    /// </list>
     /// </para>
     /// </summary>
     public sealed class StandardAnalyzer : StopwordAnalyzerBase
     {
-
         /// <summary>
         /// Default maximum allowed token length </summary>
         public const int DEFAULT_MAX_TOKEN_LENGTH = 255;
@@ -62,8 +60,7 @@ namespace Lucene.Net.Analysis.Standard
 
         /// <summary>
         /// Builds an analyzer with the given stop words. </summary>
-        /// <param name="matchVersion"> Lucene version to match See {@link
-        /// <a href="#version">above</a>} </param>
+        /// <param name="matchVersion"> Lucene compatibility version - See <see cref="StandardAnalyzer"/> </param>
         /// <param name="stopWords"> stop words  </param>
         public StandardAnalyzer(LuceneVersion matchVersion, CharArraySet stopWords)
             : base(matchVersion, stopWords)
@@ -71,10 +68,8 @@ namespace Lucene.Net.Analysis.Standard
         }
 
         /// <summary>
-        /// Builds an analyzer with the default stop words ({@link
-        /// #STOP_WORDS_SET}). </summary>
-        /// <param name="matchVersion"> Lucene version to match See {@link
-        /// <a href="#version">above</a>} </param>
+        /// Builds an analyzer with the default stop words (<see cref="STOP_WORDS_SET"/>). </summary>
+        /// <param name="matchVersion"> Lucene compatibility version - See <see cref="StandardAnalyzer"/> </param>
         public StandardAnalyzer(LuceneVersion matchVersion)
             : this(matchVersion, STOP_WORDS_SET)
         {
@@ -82,10 +77,9 @@ namespace Lucene.Net.Analysis.Standard
 
         /// <summary>
         /// Builds an analyzer with the stop words from the given reader. </summary>
-        /// <seealso cref= WordlistLoader#getWordSet(Reader, Version) </seealso>
-        /// <param name="matchVersion"> Lucene version to match See {@link
-        /// <a href="#version">above</a>} </param>
-        /// <param name="stopwords"> SetReader to read stop words from  </param>
+        /// <seealso cref="WordlistLoader.GetWordSet(TextReader, LuceneVersion)"/>
+        /// <param name="matchVersion"> Lucene compatibility version - See <see cref="StandardAnalyzer"/> </param>
+        /// <param name="stopwords"> <see cref="TextReader"/> to read stop words from  </param>
         public StandardAnalyzer(LuceneVersion matchVersion, TextReader stopwords)
             : this(matchVersion, LoadStopwordSet(stopwords, matchVersion))
         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/ab69b431/src/Lucene.Net.Analysis.Common/Analysis/Standard/StandardFilterFactory.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Standard/StandardFilterFactory.cs b/src/Lucene.Net.Analysis.Common/Analysis/Standard/StandardFilterFactory.cs
index 5476920..45417f2 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Standard/StandardFilterFactory.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Standard/StandardFilterFactory.cs
@@ -34,7 +34,7 @@ namespace Lucene.Net.Analysis.Standard
     public class StandardFilterFactory : TokenFilterFactory
     {
         /// <summary>
-        /// Creates a new StandardFilterFactory </summary>
+        /// Creates a new <see cref="StandardFilterFactory"/> </summary>
         public StandardFilterFactory(IDictionary<string, string> args)
             : base(args)
         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/ab69b431/src/Lucene.Net.Analysis.Common/Analysis/Standard/StandardTokenizer.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Standard/StandardTokenizer.cs b/src/Lucene.Net.Analysis.Common/Analysis/Standard/StandardTokenizer.cs
index deae880..dfc5ce9 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Standard/StandardTokenizer.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Standard/StandardTokenizer.cs
@@ -1,12 +1,10 @@
 using Lucene.Net.Analysis.Standard.Std31;
 using Lucene.Net.Analysis.Standard.Std34;
-using Lucene.Net.Analysis.Standard.Std36;
 using Lucene.Net.Analysis.Standard.Std40;
 using Lucene.Net.Analysis.TokenAttributes;
 using Lucene.Net.Util;
 using System;
-using Reader = System.IO.TextReader;
-using Version = Lucene.Net.Util.LuceneVersion;
+using System.IO;
 
 namespace Lucene.Net.Analysis.Standard
 {
@@ -39,21 +37,19 @@ namespace Lucene.Net.Analysis.Standard
     /// not suit your application, please consider copying this source code
     /// directory to your project and maintaining your own grammar-based tokenizer.
     /// 
-    /// <a name="version"/>
     /// </para>
     /// <para>You must specify the required <see cref="LuceneVersion"/>
-    /// compatibility when creating StandardTokenizer:
-    /// <ul>
-    ///   <li> As of 3.4, Hiragana and Han characters are no longer wrongly split
-    ///   from their combining characters. If you use a previous version number,
-    ///   you get the exact broken behavior for backwards compatibility.
-    ///   <li> As of 3.1, StandardTokenizer implements Unicode text segmentation.
-    ///   If you use a previous version number, you get the exact behavior of
-    ///   <see cref="ClassicTokenizer"/> for backwards compatibility.
-    /// </ul>
+    /// compatibility when creating <see cref="StandardTokenizer"/>:
+    /// <list type="bullet">
+    ///     <item> As of 3.4, Hiragana and Han characters are no longer wrongly split
+    ///         from their combining characters. If you use a previous version number,
+    ///         you get the exact broken behavior for backwards compatibility.</item>
+    ///     <item> As of 3.1, StandardTokenizer implements Unicode text segmentation.
+    ///         If you use a previous version number, you get the exact behavior of
+    ///         <see cref="ClassicTokenizer"/> for backwards compatibility.</item>
+    /// </list>
     /// </para>
     /// </summary>
-
     public sealed class StandardTokenizer : Tokenizer
     {
         /// <summary>
@@ -91,7 +87,22 @@ namespace Lucene.Net.Analysis.Standard
 
         /// <summary>
         /// String token types that correspond to token type int constants </summary>
-        public static readonly string[] TOKEN_TYPES = { "<ALPHANUM>", "<APOSTROPHE>", "<ACRONYM>", "<COMPANY>", "<EMAIL>", "<HOST>", "<NUM>", "<CJ>", "<ACRONYM_DEP>", "<SOUTHEAST_ASIAN>", "<IDEOGRAPHIC>", "<HIRAGANA>", "<KATAKANA>", "<HANGUL>" };
+        public static readonly string[] TOKEN_TYPES = {
+            "<ALPHANUM>",
+            "<APOSTROPHE>",
+            "<ACRONYM>",
+            "<COMPANY>",
+            "<EMAIL>",
+            "<HOST>",
+            "<NUM>",
+            "<CJ>",
+            "<ACRONYM_DEP>",
+            "<SOUTHEAST_ASIAN>",
+            "<IDEOGRAPHIC>",
+            "<HIRAGANA>",
+            "<KATAKANA>",
+            "<HANGUL>"
+        };
 
         private int skippedPositions;
 
@@ -120,42 +131,43 @@ namespace Lucene.Net.Analysis.Standard
 
         /// <summary>
         /// Creates a new instance of the <see cref="StandardTokenizer"/>.  Attaches
-        /// the <code>input</code> to the newly created JFlex scanner.
+        /// the <paramref name="input"/> to the newly created JFlex-generated (then ported to .NET) scanner.
         /// </summary>
+        /// <param name="matchVersion"> Lucene compatibility version - See <see cref="StandardTokenizer"/> </param>
         /// <param name="input"> The input reader
         /// 
         /// See http://issues.apache.org/jira/browse/LUCENE-1068 </param>
-        public StandardTokenizer(Version matchVersion, Reader input)
+        public StandardTokenizer(LuceneVersion matchVersion, TextReader input)
             : base(input)
         {
             Init(matchVersion);
         }
 
         /// <summary>
-        /// Creates a new StandardTokenizer with a given <see cref="org.apache.lucene.util.AttributeSource.AttributeFactory"/> 
+        /// Creates a new <see cref="StandardTokenizer"/> with a given <see cref="AttributeSource.AttributeFactory"/> 
         /// </summary>
-        public StandardTokenizer(Version matchVersion, AttributeFactory factory, Reader input)
+        public StandardTokenizer(LuceneVersion matchVersion, AttributeFactory factory, TextReader input)
             : base(factory, input)
         {
             Init(matchVersion);
         }
 
-        private void Init(Version matchVersion)
+        private void Init(LuceneVersion matchVersion)
         {
 #pragma warning disable 612, 618
-            if (matchVersion.OnOrAfter(Version.LUCENE_47))
+            if (matchVersion.OnOrAfter(LuceneVersion.LUCENE_47))
             {
                 this.scanner = new StandardTokenizerImpl(m_input);
             }
-            else if (matchVersion.OnOrAfter(Version.LUCENE_40))
+            else if (matchVersion.OnOrAfter(LuceneVersion.LUCENE_40))
             {
                 this.scanner = new StandardTokenizerImpl40(m_input);
             }
-            else if (matchVersion.OnOrAfter(Version.LUCENE_34))
+            else if (matchVersion.OnOrAfter(LuceneVersion.LUCENE_34))
             {
                 this.scanner = new StandardTokenizerImpl34(m_input);
             }
-            else if (matchVersion.OnOrAfter(Version.LUCENE_31))
+            else if (matchVersion.OnOrAfter(LuceneVersion.LUCENE_31))
             {
                 this.scanner = new StandardTokenizerImpl31(m_input);
             }
@@ -183,7 +195,7 @@ namespace Lucene.Net.Analysis.Standard
          *
          * @see org.apache.lucene.analysis.TokenStream#next()
          */
-        public override bool IncrementToken()
+        public override sealed bool IncrementToken()
         {
             ClearAttributes();
             skippedPositions = 0;
@@ -201,8 +213,6 @@ namespace Lucene.Net.Analysis.Standard
                 {
                     posIncrAtt.PositionIncrement = skippedPositions + 1;
                     scanner.GetText(termAtt);
-                    //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
-                    //ORIGINAL LINE: final int start = scanner.YyChar();
                     int start = scanner.YyChar;
                     offsetAtt.SetOffset(CorrectOffset(start), CorrectOffset(start + termAtt.Length));
                     // This 'if' should be removed in the next release. For now, it converts
@@ -230,7 +240,7 @@ namespace Lucene.Net.Analysis.Standard
             }
         }
 
-        public override void End()
+        public override sealed void End()
         {
             base.End();
             // set final offset

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/ab69b431/src/Lucene.Net.Analysis.Common/Analysis/Standard/StandardTokenizerFactory.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Standard/StandardTokenizerFactory.cs b/src/Lucene.Net.Analysis.Common/Analysis/Standard/StandardTokenizerFactory.cs
index cbc5915..fd3accc 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Standard/StandardTokenizerFactory.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Standard/StandardTokenizerFactory.cs
@@ -36,7 +36,7 @@ namespace Lucene.Net.Analysis.Standard
         private readonly int maxTokenLength;
 
         /// <summary>
-        /// Creates a new StandardTokenizerFactory </summary>
+        /// Creates a new <see cref="StandardTokenizerFactory"/> </summary>
         public StandardTokenizerFactory(IDictionary<string, string> args)
             : base(args)
         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/ab69b431/src/Lucene.Net.Analysis.Common/Analysis/Standard/StandardTokenizerImpl.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Standard/StandardTokenizerImpl.cs b/src/Lucene.Net.Analysis.Common/Analysis/Standard/StandardTokenizerImpl.cs
index 2e1bb36..62e0237 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Standard/StandardTokenizerImpl.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Standard/StandardTokenizerImpl.cs
@@ -26,23 +26,21 @@ namespace Lucene.Net.Analysis.Standard
     /// This class implements Word Break rules from the Unicode Text Segmentation 
     /// algorithm, as specified in 
     /// <a href="http://unicode.org/reports/tr29/">Unicode Standard Annex #29</a>. 
-    /// <p/>
+    /// <para/>
     /// Tokens produced are of the following types:
-    /// <ul>
-    ///   <li>&lt;ALPHANUM&gt;: A sequence of alphabetic and numeric characters</li>
-    ///   <li>&lt;NUM&gt;: A number</li>
-    ///   <li>&lt;SOUTHEAST_ASIAN&gt;: A sequence of characters from South and Southeast
-    ///       Asian languages, including Thai, Lao, Myanmar, and Khmer</li>
-    ///   <li>&lt;IDEOGRAPHIC&gt;: A single CJKV ideographic character</li>
-    ///   <li>&lt;HIRAGANA&gt;: A single hiragana character</li>
-    ///   <li>&lt;KATAKANA&gt;: A sequence of katakana characters</li>
-    ///   <li>&lt;HANGUL&gt;: A sequence of Hangul characters</li>
-    /// </ul>
+    /// <list type="bullet">
+    ///     <item>&lt;ALPHANUM&gt;: A sequence of alphabetic and numeric characters</item>
+    ///     <item>&lt;NUM&gt;: A number</item>
+    ///     <item>&lt;SOUTHEAST_ASIAN&gt;: A sequence of characters from South and Southeast
+    ///         Asian languages, including Thai, Lao, Myanmar, and Khmer</item>
+    ///     <item>&lt;IDEOGRAPHIC&gt;: A single CJKV ideographic character</item>
+    ///     <item>&lt;HIRAGANA&gt;: A single hiragana character</item>
+    ///     <item>&lt;KATAKANA&gt;: A sequence of katakana characters</item>
+    ///     <item>&lt;HANGUL&gt;: A sequence of Hangul characters</item>
+    /// </list>
     /// </summary>
-
     public sealed class StandardTokenizerImpl : IStandardTokenizerInterface
     {
-
         /// <summary>
         /// This character denotes the end of file </summary>
         public static readonly int YYEOF = -1;
@@ -952,12 +950,12 @@ namespace Lucene.Net.Analysis.Standard
         private int yycolumn;
 
         /// <summary>
-        /// zzAtBOL == true <=> the scanner is currently at the beginning of a line
+        /// zzAtBOL == true &lt;=&gt; the scanner is currently at the beginning of a line
         /// </summary>
         private bool zzAtBOL = true;
 
         /// <summary>
-        /// zzAtEOF == true <=> the scanner is at the EOF </summary>
+        /// zzAtEOF == true &lt;=&gt; the scanner is at the EOF </summary>
         private bool zzAtEOF;
 
         /// <summary>
@@ -1046,7 +1044,7 @@ namespace Lucene.Net.Analysis.Standard
         /// </summary>
         /// <returns>      <code>false</code>, iff there was new input.
         /// </returns>
-        /// <exception cref="java.io.IOException">  if any I/O-Error occurs </exception>
+        /// <exception cref="IOException">  if any I/O-Error occurs </exception>
         private bool ZzRefill()
         {
 
@@ -1100,7 +1098,7 @@ namespace Lucene.Net.Analysis.Standard
 
 
         /// <summary>
-        /// Closes the input stream.
+        /// Disposes the input stream.
         /// </summary>
         public void YyClose()
         {
@@ -1120,7 +1118,7 @@ namespace Lucene.Net.Analysis.Standard
         /// 
         /// All internal variables are reset, the old input stream 
         /// <b>cannot</b> be reused (internal buffer is discarded and lost).
-        /// Lexical state is set to <tt>ZZ_INITIAL</tt>.
+        /// Lexical state is set to <see cref="YYINITIAL"/>.
         /// 
         /// Internal scan buffer is resized down to its initial length, if it has grown.
         /// </summary>
@@ -1171,13 +1169,13 @@ namespace Lucene.Net.Analysis.Standard
 
 
         /// <summary>
-        /// Returns the character at position <tt>pos</tt> from the 
+        /// Returns the character at position <paramref name="pos"/> from the 
         /// matched text. 
         /// 
-        /// It is equivalent to YyText().charAt(pos), but faster
+        /// It is equivalent to YyText[pos], but faster
         /// </summary>
         /// <param name="pos"> the position of the character to fetch. 
-        ///            A value from 0 to YyLength()-1.
+        ///            A value from 0 to YyLength-1.
         /// </param>
         /// <returns> the character at position pos </returns>
         public char YyCharAt(int pos)
@@ -1197,13 +1195,13 @@ namespace Lucene.Net.Analysis.Standard
 
         /// <summary>
         /// Reports an error that occured while scanning.
-        /// 
+        /// <para/>
         /// In a wellformed scanner (no or only correct usage of 
         /// YyPushBack(int) and a match-all fallback rule) this method 
         /// will only be called with things that "Can't Possibly Happen".
         /// If this method is called, something is seriously wrong
         /// (e.g. a JFlex bug producing a faulty scanner etc.).
-        /// 
+        /// <para/>
         /// Usual syntax/scanner level error handling should be done
         /// in error fallback rules.
         /// </summary>
@@ -1230,7 +1228,7 @@ namespace Lucene.Net.Analysis.Standard
         /// They will be read again by then next call of the scanning method
         /// </summary>
         /// <param name="number">  the number of characters to be read again.
-        ///                This number must not be greater than YyLength()! </param>
+        ///                This number must not be greater than YyLength! </param>
         public void YyPushBack(int number)
         {
             if (number > YyLength)
@@ -1247,7 +1245,7 @@ namespace Lucene.Net.Analysis.Standard
         /// the end of input is encountered or an I/O-Error occurs.
         /// </summary>
         /// <returns>      the next token </returns>
-        /// <exception cref="java.io.IOException">  if any I/O-Error occurs </exception>
+        /// <exception cref="IOException">  if any I/O-Error occurs </exception>
         public int GetNextToken()
         {
             int zzInput;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/ab69b431/src/Lucene.Net.Analysis.Common/Analysis/Standard/StandardTokenizerInterface.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Standard/StandardTokenizerInterface.cs b/src/Lucene.Net.Analysis.Common/Analysis/Standard/StandardTokenizerInterface.cs
index c250996..bfd4f1f 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Standard/StandardTokenizerInterface.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Standard/StandardTokenizerInterface.cs
@@ -1,5 +1,5 @@
-using System.IO;
-using Lucene.Net.Analysis.TokenAttributes;
+using Lucene.Net.Analysis.TokenAttributes;
+using System.IO;
 
 namespace Lucene.Net.Analysis.Standard
 {
@@ -26,12 +26,8 @@ namespace Lucene.Net.Analysis.Standard
     /// </summary>
     public interface IStandardTokenizerInterface
     {
-
-        /// <summary>
-        /// This character denotes the end of file </summary>
-
         /// <summary>
-        /// Copies the matched text into the CharTermAttribute
+        /// Copies the matched text into the <see cref="ICharTermAttribute"/>
         /// </summary>
         void GetText(ICharTermAttribute t);
 
@@ -43,10 +39,10 @@ namespace Lucene.Net.Analysis.Standard
         /// <summary>
         /// Resets the scanner to read from a new input stream.
         /// Does not close the old reader.
-        /// 
+        /// <para/>
         /// All internal variables are reset, the old input stream 
         /// <b>cannot</b> be reused (internal buffer is discarded and lost).
-        /// Lexical state is set to <tt>ZZ_INITIAL</tt>.
+        /// Lexical state is set to <c>YYINITIAL</c>.
         /// </summary>
         /// <param name="reader">   the new input stream  </param>
         void YyReset(TextReader reader);
@@ -60,15 +56,15 @@ namespace Lucene.Net.Analysis.Standard
         /// Resumes scanning until the next regular expression is matched,
         /// the end of input is encountered or an I/O-Error occurs.
         /// </summary>
-        /// <returns>      the next token, <see cref="#YYEOF"/> on end of stream </returns>
+        /// <returns>      the next token, <see cref="StandardTokenizerInterface_Fields.YYEOF"/> on end of stream </returns>
         /// <exception cref="IOException">  if any I/O-Error occurs </exception>
         int GetNextToken();
-
     }
 
-    public static class StandardTokenizerInterface_Fields
+    public static class StandardTokenizerInterface_Fields // LUCENENET TODO: Rename StandardTokenizerInterface (no longer collides with interface name)
     {
+        /// <summary>
+        /// This character denotes the end of file </summary>
         public const int YYEOF = -1;
     }
-
 }
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/ab69b431/src/Lucene.Net.Analysis.Common/Analysis/Standard/Std31/StandardTokenizerImpl31.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Standard/Std31/StandardTokenizerImpl31.cs b/src/Lucene.Net.Analysis.Common/Analysis/Standard/Std31/StandardTokenizerImpl31.cs
index 533a34f..5e5667f 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Standard/Std31/StandardTokenizerImpl31.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Standard/Std31/StandardTokenizerImpl31.cs
@@ -31,27 +31,27 @@ namespace Lucene.Net.Analysis.Standard.Std31
     [Obsolete("This class is only for exact backwards compatibility")]
     public sealed class StandardTokenizerImpl31 : IStandardTokenizerInterface
     {
-        /** This character denotes the end of file */
+        /// <summary>This character denotes the end of file</summary>
         public static readonly int YYEOF = -1;
 
-        /** initial size of the lookahead buffer */
+        /// <summary>initial size of the lookahead buffer</summary>
         private static readonly int ZZ_BUFFERSIZE = 4096;
 
-        /** lexical states */
+        /// <summary>lexical states</summary>
         public const int YYINITIAL = 0;
 
-        /**
-         * ZZ_LEXSTATE[l] is the state in the DFA for the lexical state l
-         * ZZ_LEXSTATE[l+1] is the state in the DFA for the lexical state l
-         *                  at the beginning of a line
-         * l is of the form l = 2*k, k a non negative integer
-         */
+        /// <summary>
+        /// ZZ_LEXSTATE[l] is the state in the DFA for the lexical state l
+        /// ZZ_LEXSTATE[l+1] is the state in the DFA for the lexical state l
+        ///     at the beginning of a line
+        /// l is of the form l = 2*k, k a non negative integer
+        /// </summary>
         private static readonly int[] ZZ_LEXSTATE = { 0, 0 };
 
 
-        /** 
-         * Translates characters to character classes
-         */
+        /// <summary>
+        /// Translates characters to character classes
+        /// </summary>
         private const string ZZ_CMAP_PACKED =
             "\x0027\x0000\x0001\x0060\x0004\x0000\x0001\x005F\x0001\x0000\x0001\x0060\x0001\x0000\x000A\x005C\x0001\x005E\x0001\x005F" +
             "\x0005\x0000\x001A\x005A\x0004\x0000\x0001\x0061\x0001\x0000\x001A\x005A\x002F\x0000\x0001\x005A\x0002\x0000\x0001\x005B" +
@@ -187,14 +187,14 @@ namespace Lucene.Net.Analysis.Standard.Std31
             "\x000B\x0000\x0038\x005D\x0002\x005B\x001F\x0066\x0003\x0000\x0006\x0066\x0002\x0000\x0006\x0066\x0002\x0000\x0006\x0066" +
             "\x0002\x0000\x0003\x0066\x001C\x0000\x0003\x005B\x0004\x0000";
 
-        /** 
-         * Translates characters to character classes
-         */
+        /// <summary>
+        /// Translates characters to character classes
+        /// </summary>
         private static readonly char[] ZZ_CMAP = ZzUnpackCMap(ZZ_CMAP_PACKED);
 
-        /** 
-         * Translates DFA states to action switch labels.
-         */
+        /// <summary>
+        /// Translates DFA states to action switch labels.
+        /// </summary>
         private static readonly int[] ZZ_ACTION = ZzUnpackAction();
 
         private const string ZZ_ACTION_PACKED_0 =
@@ -225,9 +225,9 @@ namespace Lucene.Net.Analysis.Standard.Std31
         }
 
 
-        /** 
-         * Translates a state to a row index in the transition table
-         */
+        /// <summary>
+        /// Translates a state to a row index in the transition table
+        /// </summary>
         private static readonly int[] ZZ_ROWMAP = ZzUnpackRowMap();
 
         private const string ZZ_ROWMAP_PACKED_0 =
@@ -268,9 +268,9 @@ namespace Lucene.Net.Analysis.Standard.Std31
             return j;
         }
 
-        /** 
-         * The transition table of the DFA
-         */
+        /// <summary>
+        /// The transition table of the DFA
+        /// </summary>
         private static readonly int[] ZZ_TRANS = ZzUnpackTrans();
 
         private const string ZZ_TRANS_PACKED_0 =
@@ -615,9 +615,9 @@ namespace Lucene.Net.Analysis.Standard.Std31
             "Error: pushback value was too large"
         };
 
-        /**
-         * ZZ_ATTRIBUTE[aState] contains the attributes of state <code>aState</code>
-         */
+        /// <summary>
+        /// ZZ_ATTRIBUTE[aState] contains the attributes of state <c>aState</c>
+        /// </summary>
         private static readonly int[] ZZ_ATTRIBUTE = ZzUnpackAttribute();
 
         private const string ZZ_ATTRIBUTE_PACKED_0 =
@@ -646,73 +646,76 @@ namespace Lucene.Net.Analysis.Standard.Std31
             return j;
         }
 
-        /** the input device */
+        /// <summary>the input device</summary>
         private TextReader zzReader;
 
-        /** the current state of the DFA */
+        /// <summary>the current state of the DFA</summary>
         private int zzState;
 
-        /** the current lexical state */
+        /// <summary>the current lexical state</summary>
         private int zzLexicalState = YYINITIAL;
 
-        /** this buffer contains the current text to be matched and is
-            the source of the YyText() string */
+        /// <summary>
+        /// this buffer contains the current text to be matched and is
+        /// the source of the YyText() string
+        /// </summary>
         private char[] zzBuffer = new char[ZZ_BUFFERSIZE];
 
-        /** the textposition at the last accepting state */
+        /// <summary>the textposition at the last accepting state</summary>
         private int zzMarkedPos;
 
-        /** the current text position in the buffer */
+        /// <summary>the current text position in the buffer</summary>
         private int zzCurrentPos;
 
-        /** startRead marks the beginning of the YyText() string in the buffer */
+        /// <summary>startRead marks the beginning of the YyText string in the buffer</summary>
         private int zzStartRead;
 
-        /** endRead marks the last character in the buffer, that has been read
-            from input */
+        /// <summary>
+        /// endRead marks the last character in the buffer, that has been read
+        /// from input
+        /// </summary>
         private int zzEndRead;
 
-        /** number of newlines encountered up to the start of the matched text */
+        /// <summary>number of newlines encountered up to the start of the matched text</summary>
         private int yyline;
 
-        /** the number of characters up to the start of the matched text */
+        /// <summary>the number of characters up to the start of the matched text</summary>
         private int yyChar;
 
 #pragma warning disable 169, 414
-        /**
-         * the number of characters from the last newline up to the start of the 
-         * matched text
-         */
+
+        /// <summary>
+        /// the number of characters from the last newline up to the start of the 
+        /// matched text
+        /// </summary>
         private int yycolumn;
 
-        /** 
-         * zzAtBOL == true <=> the scanner is currently at the beginning of a line
-         */
+        /// <summary>zzAtBOL == true &lt;=&gt; the scanner is currently at the beginning of a line</summary>
         private bool zzAtBOL = true;
 
-        /** zzAtEOF == true <=> the scanner is at the EOF */
+        /// <summary>zzAtEOF == true &lt;=&gt; the scanner is at the EOF</summary>
         private bool zzAtEOF;
 
-        /** denotes if the user-EOF-code has already been executed */
+        /// <summary>denotes if the user-EOF-code has already been executed</summary>
         private bool zzEOFDone;
 
 #pragma warning disable 169, 414
 
         /* user code: */
-        /** Alphanumeric sequences */
+        /// <summary>Alphanumeric sequences</summary>
         public static readonly int WORD_TYPE = StandardTokenizer.ALPHANUM;
 
-        /** Numbers */
+        /// <summary>Numbers</summary>
         public static readonly int NUMERIC_TYPE = StandardTokenizer.NUM;
 
-        /**
-         * Chars in class \p{Line_Break = Complex_Context} are from South East Asian
-         * scripts (Thai, Lao, Myanmar, Khmer, etc.).  Sequences of these are kept 
-         * together as as a single token rather than broken up, because the logic
-         * required to break them at word boundaries is too complex for UAX#29.
-         * <p>
-         * See Unicode Line Breaking Algorithm: http://www.unicode.org/reports/tr14/#SA
-         */
+        /// <summary>
+        /// Chars in class \p{Line_Break = Complex_Context} are from South East Asian
+        /// scripts (Thai, Lao, Myanmar, Khmer, etc.).  Sequences of these are kept 
+        /// together as as a single token rather than broken up, because the logic
+        /// required to break them at word boundaries is too complex for UAX#29.
+        /// <para/>
+        /// See Unicode Line Breaking Algorithm: http://www.unicode.org/reports/tr14/#SA
+        /// </summary>
         public static readonly int SOUTH_EAST_ASIAN_TYPE = StandardTokenizer.SOUTHEAST_ASIAN;
 
         public static readonly int IDEOGRAPHIC_TYPE = StandardTokenizer.IDEOGRAPHIC;
@@ -728,32 +731,26 @@ namespace Lucene.Net.Analysis.Standard.Std31
             get { return yyChar; }
         }
 
-        /**
-         * Fills CharTermAttribute with the current token text.
-         */
+        /// <summary>Fills ICharTermAttribute with the current token text.</summary>
         public void GetText(ICharTermAttribute t)
         {
             t.CopyBuffer(zzBuffer, zzStartRead, zzMarkedPos - zzStartRead);
         }
 
-
-        /**
-         * Creates a new scanner
-         *
-         * @param   in  the TextReader to read input from.
-         */
+        /// <summary>
+        /// Creates a new scanner
+        /// </summary>
+        /// <param name="in">the TextReader to read input from.</param>
         public StandardTokenizerImpl31(TextReader @in)
         {
             this.zzReader = @in;
         }
 
-
-        /** 
-         * Unpacks the compressed character translation table.
-         *
-         * @param packed   the packed character translation table
-         * @return         the unpacked character translation table
-         */
+        /// <summary>
+        /// Unpacks the compressed character translation table.
+        /// </summary>
+        /// <param name="packed">the packed character translation table</param>
+        /// <returns>the unpacked character translation table</returns>
         private static char[] ZzUnpackCMap(string packed)
         {
             char[] map = new char[0x10000];
@@ -768,14 +765,11 @@ namespace Lucene.Net.Analysis.Standard.Std31
             return map;
         }
 
-
-        /**
-         * Refills the input buffer.
-         *
-         * @return      <code>false</code>, iff there was new input.
-         * 
-         * @exception   java.io.IOException  if any I/O-Error occurs
-         */
+        /// <summary>
+        /// Refills the input buffer.
+        /// </summary>
+        /// <returns><c>false</c>, iff there was new input.</returns>
+        /// <exception cref="IOException">if any I/O-Error occurs</exception>
         private bool ZzRefill()
         {
 
@@ -831,9 +825,9 @@ namespace Lucene.Net.Analysis.Standard.Std31
         }
 
 
-        /**
-         * Closes the input stream.
-         */
+        /// <summary>
+        /// Disposes the input stream.
+        /// </summary>
         public void YyClose()
         {
             zzAtEOF = true;            /* indicate end of file */
@@ -843,19 +837,16 @@ namespace Lucene.Net.Analysis.Standard.Std31
                 zzReader.Dispose();
         }
 
-
-        /**
-         * Resets the scanner to read from a new input stream.
-         * Does not close the old reader.
-         *
-         * All internal variables are reset, the old input stream 
-         * <b>cannot</b> be reused (internal buffer is discarded and lost).
-         * Lexical state is set to <tt>ZZ_INITIAL</tt>.
-         *
-         * Internal scan buffer is resized down to its initial length, if it has grown.
-         *
-         * @param reader   the new input stream 
-         */
+        /// <summary>
+        /// Resets the scanner to read from a new input stream.
+        /// Does not close the old reader.
+        /// <para/>
+        /// All internal variables are reset, the old input stream 
+        /// <b>cannot</b> be reused (internal buffer is discarded and lost).
+        /// Lexical state is set to <see cref="YYINITIAL"/>.
+        /// Internal scan buffer is resized down to its initial length, if it has grown.
+        /// </summary>
+        /// <param name="reader">the new input stream </param>
         public void YyReset(TextReader reader)
         {
             zzReader = reader;
@@ -871,75 +862,69 @@ namespace Lucene.Net.Analysis.Standard.Std31
         }
 
 
-        /**
-         * Returns the current lexical state.
-         */
+        /// <summary>
+        /// Returns the current lexical state.
+        /// </summary>
         public int YyState
         {
             get { return zzLexicalState; }
         }
 
-
-        /**
-         * Enters a new lexical state
-         *
-         * @param newState the new lexical state
-         */
+        /// <summary>
+        /// Enters a new lexical state
+        /// </summary>
+        /// <param name="newState">the new lexical state</param>
         public void YyBegin(int newState)
         {
             zzLexicalState = newState;
         }
 
 
-        /**
-         * Returns the text matched by the current regular expression.
-         */
+        /// <summary>
+        /// Returns the text matched by the current regular expression.
+        /// </summary>
         public string YyText
         {
             get { return new string(zzBuffer, zzStartRead, zzMarkedPos - zzStartRead); }
         }
 
-
-        /**
-         * Returns the character at position <tt>pos</tt> from the 
-         * matched text. 
-         * 
-         * It is equivalent to YyText().charAt(pos), but faster
-         *
-         * @param pos the position of the character to fetch. 
-         *            A value from 0 to YyLength()-1.
-         *
-         * @return the character at position pos
-         */
+        /// <summary>
+        /// Returns the character at position <paramref name="pos"/> from the 
+        /// matched text.
+        /// <para/>
+        /// It is equivalent to YyText[pos], but faster
+        /// </summary>
+        /// <param name="pos">
+        /// the position of the character to fetch.
+        /// A value from 0 to YyLength-1.
+        /// </param>
+        /// <returns>the character at position pos</returns>
         public char YyCharAt(int pos)
         {
             return zzBuffer[zzStartRead + pos];
         }
 
 
-        /**
-         * Returns the length of the matched text region.
-         */
+        /// <summary>
+        /// Returns the length of the matched text region.
+        /// </summary>
         public int YyLength
         {
             get { return zzMarkedPos - zzStartRead; }
         }
 
-
-        /**
-         * Reports an error that occured while scanning.
-         *
-         * In a wellformed scanner (no or only correct usage of 
-         * YyPushBack(int) and a match-all fallback rule) this method 
-         * will only be called with things that "Can't Possibly Happen".
-         * If this method is called, something is seriously wrong
-         * (e.g. a JFlex bug producing a faulty scanner etc.).
-         *
-         * Usual syntax/scanner level error handling should be done
-         * in error fallback rules.
-         *
-         * @param   errorCode  the code of the errormessage to display
-         */
+        /// <summary>
+        /// Reports an error that occured while scanning.
+        /// <para/>
+        /// In a wellformed scanner (no or only correct usage of 
+        /// YyPushBack(int) and a match-all fallback rule) this method 
+        /// will only be called with things that "Can't Possibly Happen".
+        /// If this method is called, something is seriously wrong
+        /// (e.g. a JFlex bug producing a faulty scanner etc.).
+        /// Usual syntax/scanner level error handling should be done
+        /// in error fallback rules.
+        /// </summary>
+        /// <param name="errorCode">the code of the errormessage to display</param>
         private void ZzScanError(int errorCode)
         {
             string message;
@@ -955,15 +940,15 @@ namespace Lucene.Net.Analysis.Standard.Std31
             throw new Exception(message);
         }
 
-
-        /**
-         * Pushes the specified amount of characters back into the input stream.
-         *
-         * They will be read again by then next call of the scanning method
-         *
-         * @param number  the number of characters to be read again.
-         *                This number must not be greater than YyLength()!
-         */
+        /// <summary>
+        /// Pushes the specified amount of characters back into the input stream.
+        /// <para/>
+        /// They will be read again by then next call of the scanning method
+        /// </summary>
+        /// <param name="number">
+        /// the number of characters to be read again.
+        /// This number must not be greater than YyLength!
+        /// </param>
         public void YyPushBack(int number)
         {
             if (number > YyLength)
@@ -972,14 +957,12 @@ namespace Lucene.Net.Analysis.Standard.Std31
             zzMarkedPos -= number;
         }
 
-
-        /**
-         * Resumes scanning until the next regular expression is matched,
-         * the end of input is encountered or an I/O-Error occurs.
-         *
-         * @return      the next token
-         * @exception   java.io.IOException  if any I/O-Error occurs
-         */
+        /// <summary>
+        /// Resumes scanning until the next regular expression is matched,
+        /// the end of input is encountered or an I/O-Error occurs.
+        /// </summary>
+        /// <returns>the next token</returns>
+        /// <exception cref="IOException">if any I/O-Error occurs</exception>
         public int GetNextToken()
         {
             int zzInput;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/ab69b431/src/Lucene.Net.Analysis.Common/Analysis/Standard/Std31/UAX29URLEmailTokenizerImpl31.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Standard/Std31/UAX29URLEmailTokenizerImpl31.cs b/src/Lucene.Net.Analysis.Common/Analysis/Standard/Std31/UAX29URLEmailTokenizerImpl31.cs
index 324b47b..4fd4938 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Standard/Std31/UAX29URLEmailTokenizerImpl31.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Standard/Std31/UAX29URLEmailTokenizerImpl31.cs
@@ -3160,7 +3160,7 @@ namespace Lucene.Net.Analysis.Standard.Std31
             "Error: pushback value was too large"
         };
 
-        /// <summary>ZZ_ATTRIBUTE[aState] contains the attributes of state <code>aState</code></summary>
+        /// <summary>ZZ_ATTRIBUTE[aState] contains the attributes of state <c>aState</c></summary>
         private static readonly int[] ZZ_ATTRIBUTE = ZzUnpackAttribute();
 
         private const string ZZ_ATTRIBUTE_PACKED_0 =
@@ -3204,70 +3204,73 @@ namespace Lucene.Net.Analysis.Standard.Std31
         /// <summary>the input device</summary>
         private TextReader zzReader;
 
-        /** the current state of the DFA */
+        /// <summary>the current state of the DFA</summary>
         private int zzState;
 
-        /** the current lexical state */
+        /// <summary>the current lexical state</summary>
         private int zzLexicalState = YYINITIAL;
 
-        /** this buffer contains the current text to be matched and is
-            the source of the YyText() string */
+        /// <summary>
+        /// this buffer contains the current text to be matched and is
+        /// the source of the YyText string
+        /// </summary>
         private char[] zzBuffer = new char[ZZ_BUFFERSIZE];
 
-        /** the textposition at the last accepting state */
+        /// <summary>the textposition at the last accepting state</summary>
         private int zzMarkedPos;
 
-        /** the current text position in the buffer */
+        /// <summary>the current text position in the buffer</summary>
         private int zzCurrentPos;
 
-        /** startRead marks the beginning of the YyText() string in the buffer */
+        /// <summary>startRead marks the beginning of the YyText string in the buffer</summary>
         private int zzStartRead;
 
-        /** endRead marks the last character in the buffer, that has been read
-            from input */
+        /// <summary>
+        /// endRead marks the last character in the buffer, that has been read
+        /// from input
+        /// </summary>
         private int zzEndRead;
 
-        /** number of newlines encountered up to the start of the matched text */
+        /// <summary>number of newlines encountered up to the start of the matched text</summary>
         private int yyline;
 
-        /** the number of characters up to the start of the matched text */
+        /// <summary>the number of characters up to the start of the matched text</summary>
         private int yychar;
 
 #pragma warning disable 169, 414
-        /**
-         * the number of characters from the last newline up to the start of the 
-         * matched text
-         */
+
+        /// <summary>
+        /// the number of characters from the last newline up to the start of the 
+        /// matched text
+        /// </summary>
         private int yycolumn;
 
-        /** 
-         * zzAtBOL == true <=> the scanner is currently at the beginning of a line
-         */
+        /// <summary>zzAtBOL == true &lt;=&gt; the scanner is currently at the beginning of a line</summary>
         private bool zzAtBOL = true;
 
-        /** zzAtEOF == true <=> the scanner is at the EOF */
+        /// <summary>zzAtEOF == true &lt;=&gt; the scanner is at the EOF</summary>
         private bool zzAtEOF;
 
-        /** denotes if the user-EOF-code has already been executed */
+        /// <summary>denotes if the user-EOF-code has already been executed</summary>
         private bool zzEOFDone;
 
 #pragma warning restore 169, 414
 
         /* user code: */
-        /** Alphanumeric sequences */
+        /// <summary>Alphanumeric sequences</summary>
         public static readonly int WORD_TYPE = UAX29URLEmailTokenizer.ALPHANUM;
 
-        /** Numbers */
+        /// <summary>Numbers</summary>
         public static readonly int NUMERIC_TYPE = UAX29URLEmailTokenizer.NUM;
 
-        /**
-         * Chars in class \p{Line_Break = Complex_Context} are from South East Asian
-         * scripts (Thai, Lao, Myanmar, Khmer, etc.).  Sequences of these are kept 
-         * together as as a single token rather than broken up, because the logic
-         * required to break them at word boundaries is too complex for UAX#29.
-         * <p>
-         * See Unicode Line Breaking Algorithm: http://www.unicode.org/reports/tr14/#SA
-         */
+        /// <summary>
+        /// Chars in class \p{Line_Break = Complex_Context} are from South East Asian
+        /// scripts (Thai, Lao, Myanmar, Khmer, etc.).  Sequences of these are kept 
+        /// together as as a single token rather than broken up, because the logic
+        /// required to break them at word boundaries is too complex for UAX#29.
+        /// <para/>
+        /// See Unicode Line Breaking Algorithm: http://www.unicode.org/reports/tr14/#SA
+        /// </summary>
         public static readonly int SOUTH_EAST_ASIAN_TYPE = UAX29URLEmailTokenizer.SOUTHEAST_ASIAN;
 
         public static readonly int IDEOGRAPHIC_TYPE = UAX29URLEmailTokenizer.IDEOGRAPHIC;
@@ -3399,7 +3402,7 @@ namespace Lucene.Net.Analysis.Standard.Std31
         /// 
         /// All internal variables are reset, the old input stream 
         /// <b>cannot</b> be reused (internal buffer is discarded and lost).
-        /// Lexical state is set to <tt>ZZ_INITIAL</tt>.
+        /// Lexical state is set to <see cref="YYINITIAL"/>.
         /// 
         /// Internal scan buffer is resized down to its initial length, if it has grown.
         /// </summary>
@@ -3447,10 +3450,10 @@ namespace Lucene.Net.Analysis.Standard.Std31
         /// Returns the character at position <tt>pos</tt> from the 
         /// matched text. 
         /// 
-        /// It is equivalent to YyText().charAt(pos), but faster
+        /// It is equivalent to YyText[pos], but faster
         /// </summary>
         /// <param name="pos">the position of the character to fetch. 
-        /// A value from 0 to YyLength()-1.</param>
+        /// A value from 0 to YyLength-1.</param>
         /// <returns>the character at position pos</returns>
         public char YyCharAt(int pos)
         {
@@ -3498,7 +3501,7 @@ namespace Lucene.Net.Analysis.Standard.Std31
         /// They will be read again by then next call of the scanning method
         /// </summary>
         /// <param name="number">the number of characters to be read again.
-        /// This number must not be greater than YyLength()!</param>
+        /// This number must not be greater than YyLength!</param>
         public void YyPushBack(int number)
         {
             if (number > YyLength)
@@ -3513,7 +3516,7 @@ namespace Lucene.Net.Analysis.Standard.Std31
         /// the end of input is encountered or an I/O-Error occurs.
         /// </summary>
         /// <returns>      the next token </returns>
-        /// <exception cref="java.io.IOException">  if any I/O-Error occurs </exception>
+        /// <exception cref="IOException">  if any I/O-Error occurs </exception>
         public int GetNextToken()
         {
             int zzInput;


Mime
View raw message