lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From nightowl...@apache.org
Subject [4/8] lucenenet git commit: Lucene.Net.Analysis.Pt refactor: member accessibility and documentation comments
Date Fri, 03 Feb 2017 21:06:39 GMT
Lucene.Net.Analysis.Pt 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/73a3384a
Tree: http://git-wip-us.apache.org/repos/asf/lucenenet/tree/73a3384a
Diff: http://git-wip-us.apache.org/repos/asf/lucenenet/diff/73a3384a

Branch: refs/heads/api-work
Commit: 73a3384ad1b4d0aac9164aeb8bcf68771789351b
Parents: c2f2f0d
Author: Shad Storhaug <shad@shadstorhaug.com>
Authored: Sat Feb 4 03:30:57 2017 +0700
Committer: Shad Storhaug <shad@shadstorhaug.com>
Committed: Sat Feb 4 03:30:57 2017 +0700

----------------------------------------------------------------------
 .../Analysis/Pt/PortugueseAnalyzer.cs           | 23 +++--
 .../Analysis/Pt/PortugueseLightStemFilter.cs    |  4 +-
 .../Pt/PortugueseLightStemFilterFactory.cs      |  5 +-
 .../Analysis/Pt/PortugueseLightStemmer.cs       |  3 +-
 .../Analysis/Pt/PortugueseMinimalStemFilter.cs  |  4 +-
 .../Pt/PortugueseMinimalStemFilterFactory.cs    |  5 +-
 .../Analysis/Pt/PortugueseMinimalStemmer.cs     |  9 +-
 .../Analysis/Pt/PortugueseStemFilter.cs         |  4 +-
 .../Analysis/Pt/PortugueseStemFilterFactory.cs  |  6 +-
 .../Analysis/Pt/PortugueseStemmer.cs            |  2 +-
 .../Analysis/Pt/RSLPStemmerBase.cs              | 88 ++++++++++----------
 11 files changed, 71 insertions(+), 82 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/lucenenet/blob/73a3384a/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseAnalyzer.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseAnalyzer.cs b/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseAnalyzer.cs
index a51dae7..066c62a 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseAnalyzer.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseAnalyzer.cs
@@ -29,14 +29,11 @@ namespace Lucene.Net.Analysis.Pt
 
     /// <summary>
     /// <see cref="Analyzer"/> for Portuguese.
-    /// <para>
-    /// <a name="version"/>
-    /// </para>
     /// <para>You must specify the required <see cref="LuceneVersion"/>
-    /// compatibility when creating PortugueseAnalyzer:
-    /// <ul>
-    ///   <li> As of 3.6, PortugueseLightStemFilter is used for less aggressive stemming.
-    /// </ul>
+    /// compatibility when creating <see cref="PortugueseAnalyzer"/>:
+    /// <list type="bullet">
+    ///     <item> As of 3.6, PortugueseLightStemFilter is used for less aggressive
stemming.</item>
+    /// </list>
     /// </para>
     /// </summary>
     public sealed class PortugueseAnalyzer : StopwordAnalyzerBase
@@ -59,7 +56,7 @@ namespace Lucene.Net.Analysis.Pt
         }
 
         /// <summary>
-        /// Atomically loads the DEFAULT_STOP_SET in a lazy fashion once the outer class

+        /// Atomically loads the <see cref="DEFAULT_STOP_SET"/> in a lazy fashion once
the outer class 
         /// accesses the static final set the first time.;
         /// </summary>
         private class DefaultSetHolder
@@ -87,10 +84,10 @@ namespace Lucene.Net.Analysis.Pt
         }
 
         /// <summary>
-        /// Builds an analyzer with the default stop words: <see cref="#DEFAULT_STOPWORD_FILE"/>.
+        /// Builds an analyzer with the default stop words: <see cref="DEFAULT_STOPWORD_FILE"/>.
         /// </summary>
         public PortugueseAnalyzer(LuceneVersion matchVersion)
-              : this(matchVersion, DefaultSetHolder.DEFAULT_STOP_SET)
+            : this(matchVersion, DefaultSetHolder.DEFAULT_STOP_SET)
         {
         }
 
@@ -100,7 +97,7 @@ namespace Lucene.Net.Analysis.Pt
         /// <param name="matchVersion"> lucene compatibility version </param>
         /// <param name="stopwords"> a stopword set </param>
         public PortugueseAnalyzer(LuceneVersion matchVersion, CharArraySet stopwords)
-              : this(matchVersion, stopwords, CharArraySet.EMPTY_SET)
+            : this(matchVersion, stopwords, CharArraySet.EMPTY_SET)
         {
         }
 
@@ -113,7 +110,7 @@ namespace Lucene.Net.Analysis.Pt
         /// <param name="stopwords"> a stopword set </param>
         /// <param name="stemExclusionSet"> a set of terms not to be stemmed </param>
         public PortugueseAnalyzer(LuceneVersion matchVersion, CharArraySet stopwords, CharArraySet
stemExclusionSet)
-              : base(matchVersion, stopwords)
+            : base(matchVersion, stopwords)
         {
             this.stemExclusionSet = CharArraySet.UnmodifiableSet(CharArraySet.Copy(matchVersion,
stemExclusionSet));
         }
@@ -121,7 +118,7 @@ namespace Lucene.Net.Analysis.Pt
         /// <summary>
         /// Creates a
         /// <see cref="Analyzer.TokenStreamComponents"/>
-        /// which tokenizes all the text in the provided <see cref="Reader"/>.
+        /// which tokenizes all the text in the provided <see cref="TextReader"/>.
         /// </summary>
         /// <returns> A
         ///         <see cref="Analyzer.TokenStreamComponents"/>

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/73a3384a/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseLightStemFilter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseLightStemFilter.cs b/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseLightStemFilter.cs
index e557bff..d4ff6e6 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseLightStemFilter.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseLightStemFilter.cs
@@ -24,7 +24,7 @@ namespace Lucene.Net.Analysis.Pt
     /// Portuguese words.
     /// <para>
     /// To prevent terms from being stemmed use an instance of
-    /// <see cref="SetKeywordMarkerFilter"/> or a custom <see cref="TokenFilter"/>
that sets
+    /// <see cref="Miscellaneous.SetKeywordMarkerFilter"/> or a custom <see cref="TokenFilter"/>
that sets
     /// the <see cref="KeywordAttribute"/> before this <see cref="TokenStream"/>.
     /// </para>
     /// </summary>
@@ -35,7 +35,7 @@ namespace Lucene.Net.Analysis.Pt
         private readonly IKeywordAttribute keywordAttr;
 
         public PortugueseLightStemFilter(TokenStream input)
-              : base(input)
+            : base(input)
         {
             termAtt = AddAttribute<ICharTermAttribute>();
             keywordAttr = AddAttribute<IKeywordAttribute>();

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/73a3384a/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseLightStemFilterFactory.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseLightStemFilterFactory.cs
b/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseLightStemFilterFactory.cs
index 12dbdfd..d999823 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseLightStemFilterFactory.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseLightStemFilterFactory.cs
@@ -33,11 +33,10 @@ namespace Lucene.Net.Analysis.Pt
     /// </summary>
     public class PortugueseLightStemFilterFactory : TokenFilterFactory
     {
-
         /// <summary>
-        /// Creates a new PortugueseLightStemFilterFactory </summary>
+        /// Creates a new <see cref="PortugueseLightStemFilterFactory"/> </summary>
         public PortugueseLightStemFilterFactory(IDictionary<string, string> args)
-              : base(args)
+            : base(args)
         {
             if (args.Count > 0)
             {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/73a3384a/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseLightStemmer.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseLightStemmer.cs b/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseLightStemmer.cs
index 533ba2d..acf0b76 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseLightStemmer.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseLightStemmer.cs
@@ -58,13 +58,12 @@ namespace Lucene.Net.Analysis.Pt
     /// Light Stemmer for Portuguese
     /// <para>
     /// This stemmer implements the "UniNE" algorithm in:
-    /// <i>Light Stemming Approaches for the French, Portuguese, German and Hungarian
Languages</i>
+    /// <c>Light Stemming Approaches for the French, Portuguese, German and Hungarian
Languages</c>
     /// Jacques Savoy
     /// </para>
     /// </summary>
     public class PortugueseLightStemmer
     {
-
         public virtual int Stem(char[] s, int len)
         {
             if (len < 4)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/73a3384a/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseMinimalStemFilter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseMinimalStemFilter.cs b/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseMinimalStemFilter.cs
index 6f63d4c..0d0659d 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseMinimalStemFilter.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseMinimalStemFilter.cs
@@ -24,7 +24,7 @@ namespace Lucene.Net.Analysis.Pt
     /// Portuguese words.
     /// <para>
     /// To prevent terms from being stemmed use an instance of
-    /// <see cref="SetKeywordMarkerFilter"/> or a custom <see cref="TokenFilter"/>
that sets
+    /// <see cref="Miscellaneous.SetKeywordMarkerFilter"/> or a custom <see cref="TokenFilter"/>
that sets
     /// the <see cref="KeywordAttribute"/> before this <see cref="TokenStream"/>.
     /// </para>
     /// </summary>
@@ -35,7 +35,7 @@ namespace Lucene.Net.Analysis.Pt
         private readonly IKeywordAttribute keywordAttr;
 
         public PortugueseMinimalStemFilter(TokenStream input)
-              : base(input)
+            : base(input)
         {
             termAtt = AddAttribute<ICharTermAttribute>();
             keywordAttr = AddAttribute<IKeywordAttribute>();

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/73a3384a/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseMinimalStemFilterFactory.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseMinimalStemFilterFactory.cs
b/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseMinimalStemFilterFactory.cs
index db1927f..7d20b15 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseMinimalStemFilterFactory.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseMinimalStemFilterFactory.cs
@@ -33,11 +33,10 @@ namespace Lucene.Net.Analysis.Pt
     /// </summary>
     public class PortugueseMinimalStemFilterFactory : TokenFilterFactory
     {
-
         /// <summary>
-        /// Creates a new PortugueseMinimalStemFilterFactory </summary>
+        /// Creates a new <see cref="PortugueseMinimalStemFilterFactory"/> </summary>
         public PortugueseMinimalStemFilterFactory(IDictionary<string, string> args)
-              : base(args)
+            : base(args)
         {
             if (args.Count > 0)
             {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/73a3384a/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseMinimalStemmer.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseMinimalStemmer.cs b/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseMinimalStemmer.cs
index ba5900c..0671763 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseMinimalStemmer.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseMinimalStemmer.cs
@@ -21,17 +21,16 @@
     /// Minimal Stemmer for Portuguese
     /// <para>
     /// This follows the "RSLP-S" algorithm presented in:
-    /// <i>A study on the Use of Stemming for Monolingual Ad-Hoc Portuguese
-    /// Information Retrieval</i> (Orengo, et al)
+    /// <c>A study on the Use of Stemming for Monolingual Ad-Hoc Portuguese
+    /// Information Retrieval</c> (Orengo, et al)
     /// which is just the plural reduction step of the RSLP
-    /// algorithm from <i>A Stemming Algorithm for the Portuguese Language</i>,
+    /// algorithm from <c>A Stemming Algorithm for the Portuguese Language</c>,
     /// Orengo et al.
     /// </para>
     /// </summary>
-    /// <seealso cref= RSLPStemmerBase </seealso>
+    /// <seealso cref="RSLPStemmerBase"/>
     public class PortugueseMinimalStemmer : RSLPStemmerBase
     {
-
         private static readonly Step pluralStep = Parse(typeof(PortugueseMinimalStemmer),
"portuguese.rslp")["Plural"];
 
         public virtual int Stem(char[] s, int len)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/73a3384a/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseStemFilter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseStemFilter.cs b/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseStemFilter.cs
index 560b64a..8ea84e1 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseStemFilter.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseStemFilter.cs
@@ -24,7 +24,7 @@ namespace Lucene.Net.Analysis.Pt
     /// Portuguese words.
     /// <para>
     /// To prevent terms from being stemmed use an instance of
-    /// <see cref="SetKeywordMarkerFilter"/> or a custom <see cref="TokenFilter"/>
that sets
+    /// <see cref="Miscellaneous.SetKeywordMarkerFilter"/> or a custom <see cref="TokenFilter"/>
that sets
     /// the <see cref="KeywordAttribute"/> before this <see cref="TokenStream"/>.
     /// </para>
     /// </summary>
@@ -35,7 +35,7 @@ namespace Lucene.Net.Analysis.Pt
         private readonly IKeywordAttribute keywordAttr;
 
         public PortugueseStemFilter(TokenStream input)
-              : base(input)
+            : base(input)
         {
             termAtt = AddAttribute<ICharTermAttribute>();
             keywordAttr = AddAttribute<IKeywordAttribute>();

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/73a3384a/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseStemFilterFactory.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseStemFilterFactory.cs b/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseStemFilterFactory.cs
index 46a5a67..1ffce63 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseStemFilterFactory.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseStemFilterFactory.cs
@@ -33,10 +33,10 @@ namespace Lucene.Net.Analysis.Pt
     /// </summary>
     public class PortugueseStemFilterFactory : TokenFilterFactory
     {
-
         /// <summary>
-        /// Creates a new PortugueseStemFilterFactory </summary>
-        public PortugueseStemFilterFactory(IDictionary<string, string> args) : base(args)
+        /// Creates a new <see cref="PortugueseStemFilterFactory"/> </summary>
+        public PortugueseStemFilterFactory(IDictionary<string, string> args) 
+            : base(args)
         {
             if (args.Count > 0)
             {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/73a3384a/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseStemmer.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseStemmer.cs b/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseStemmer.cs
index 774b64c..d48768d 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseStemmer.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Pt/PortugueseStemmer.cs
@@ -24,7 +24,7 @@ namespace Lucene.Net.Analysis.Pt
     /// Portuguese stemmer implementing the RSLP (Removedor de Sufixos da Lingua Portuguesa)
     /// algorithm. This is sometimes also referred to as the Orengo stemmer.
     /// </summary>
-    /// <seealso cref= RSLPStemmerBase </seealso>
+    /// <seealso cref="RSLPStemmerBase"/>
     public class PortugueseStemmer : RSLPStemmerBase
     {
         private static readonly Step plural, feminine, adverb, augmentative, noun, verb,
vowel;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/73a3384a/src/Lucene.Net.Analysis.Common/Analysis/Pt/RSLPStemmerBase.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Pt/RSLPStemmerBase.cs b/src/Lucene.Net.Analysis.Common/Analysis/Pt/RSLPStemmerBase.cs
index 8e72225..3b5fcfa 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Pt/RSLPStemmerBase.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Pt/RSLPStemmerBase.cs
@@ -1,13 +1,12 @@
-´╗┐using System;
-using System.Diagnostics;
-using System.Collections.Generic;
-using Lucene.Net.Analysis.Util;
-using Lucene.Net.Util;
+´╗┐using Lucene.Net.Analysis.Util;
 using Lucene.Net.Support;
+using Lucene.Net.Util;
+using System;
+using System.Collections.Generic;
 using System.IO;
-using System.Text.RegularExpressions;
-using System.Text;
 using System.Linq;
+using System.Text;
+using System.Text.RegularExpressions;
 
 namespace Lucene.Net.Analysis.Pt
 {
@@ -33,27 +32,27 @@ namespace Lucene.Net.Analysis.Pt
     /// <para>
     /// RSLP (Removedor de Sufixos da Lingua Portuguesa) is an algorithm designed
     /// originally for stemming the Portuguese language, described in the paper
-    /// <i>A Stemming Algorithm for the Portuguese Language</i>, Orengo et. al.
+    /// <c>A Stemming Algorithm for the Portuguese Language</c>, Orengo et. al.
     /// </para>
     /// <para>
     /// Since this time a plural-only modification (RSLP-S) as well as a modification
     /// for the Galician language have been implemented. This class parses a configuration
-    /// file that describes <see cref="Step"/>s, where each Step contains a set of
<see cref="Rule"/>s.
+    /// file that describes <see cref="Step"/>s, where each <see cref="Step"/>
contains a set of <see cref="Rule"/>s.
     /// </para>
     /// <para>
     /// The general rule format is: 
-    /// <blockquote>{ "suffix", N, "replacement", { "exception1", "exception2", ...}}</blockquote>
+    /// <code>{ "suffix", N, "replacement", { "exception1", "exception2", ...}}</code>
     /// where:
-    /// <ul>
-    ///   <li><code>suffix</code> is the suffix to be removed (such as
"inho").
-    ///   <li><code>N</code> is the min stem size, where stem is defined
as the candidate stem 
-    ///       after removing the suffix (but before appending the replacement!)
-    ///   <li><code>replacement</code> is an optimal string to append after
removing the suffix.
-    ///       This can be the empty string.
-    ///   <li><code>exceptions</code> is an optional list of exceptions,
patterns that should 
+    /// <list type="bullet">
+    ///   <item><c>suffix</c> is the suffix to be removed (such as "inho").</item>
+    ///   <item><c>N</c> is the min stem size, where stem is defined as
the candidate stem 
+    ///       after removing the suffix (but before appending the replacement!)</item>
+    ///   <item><c>replacement</c> is an optimal string to append after
removing the suffix.
+    ///       This can be the empty string.</item>
+    ///   <item><c>exceptions</c> is an optional list of exceptions, patterns
that should 
     ///       not be stemmed. These patterns can be specified as whole word or suffix (ends-with)

-    ///       patterns, depending upon the exceptions format flag in the step header.
-    /// </ul>
+    ///       patterns, depending upon the exceptions format flag in the step header.</item>
+    /// </list>
     /// </para>
     /// <para>
     /// A step is an ordered list of rules, with a structure in this format:
@@ -61,35 +60,32 @@ namespace Lucene.Net.Analysis.Pt
     ///               ... rules ... };
     /// </blockquote>
     /// where:
-    /// <ul>
-    ///   <li><code>name</code> is a name for the step (such as "Plural").
-    ///   <li><code>N</code> is the min word size. Words that are less
than this length bypass
+    /// <list type="bullet">
+    ///   <item><c>name</c> is a name for the step (such as "Plural").</item>
+    ///   <item><c>N</c> is the min word size. Words that are less than
this length bypass
     ///       the step completely, as an optimization. Note: N can be zero, in this case
this 
     ///       implementation will automatically calculate the appropriate value from the
underlying 
-    ///       rules.
-    ///   <li><code>B</code> is a "boolean" flag specifying how exceptions
in the rules are matched.
+    ///       rules.</item>
+    ///   <item><c>B</c> is a "boolean" flag specifying how exceptions
in the rules are matched.
     ///       A value of 1 indicates whole-word pattern matching, a value of 0 indicates
that 
-    ///       exceptions are actually suffixes and should be matched with ends-with.
-    ///   <li><code>conds</code> are an optional list of conditions to
enter the step at all. If
+    ///       exceptions are actually suffixes and should be matched with ends-with.</item>
+    ///   <item><c>conds</c> are an optional list of conditions to enter
the step at all. If
     ///       the list is non-empty, then a word must end with one of these conditions or
it will
-    ///       bypass the step completely as an optimization.
-    /// </ul>
-    /// </para>
-    /// <para>
+    ///       bypass the step completely as an optimization.</item>
+    /// </list>
     /// </para>
+    /// <a href="http://www.inf.ufrgs.br/~viviane/rslp/index.htm">RSLP description</a>
+    /// @lucene.internal
     /// </summary>
-    /// <seealso cref= <a href="http://www.inf.ufrgs.br/~viviane/rslp/index.htm">RSLP
description</a>
-    /// @lucene.internal </seealso>
     public abstract class RSLPStemmerBase
     {
-
         /// <summary>
         /// A basic rule, with no exceptions.
         /// </summary>
-        protected internal class Rule
+        protected class Rule
         {
             protected internal readonly char[] m_suffix;
-            protected internal readonly char[] m_replacement;
+            protected readonly char[] m_replacement;
             protected internal readonly int m_min;
 
             /// <summary>
@@ -124,9 +120,9 @@ namespace Lucene.Net.Analysis.Pt
         /// <summary>
         /// A rule with a set of whole-word exceptions.
         /// </summary>
-        protected internal class RuleWithSetExceptions : Rule
+        protected class RuleWithSetExceptions : Rule
         {
-            protected internal readonly CharArraySet m_exceptions;
+            protected readonly CharArraySet m_exceptions;
 
             public RuleWithSetExceptions(string suffix, int min, string replacement, string[]
exceptions) : base(suffix, min, replacement)
             {
@@ -153,10 +149,10 @@ namespace Lucene.Net.Analysis.Pt
         /// <summary>
         /// A rule with a set of exceptional suffixes.
         /// </summary>
-        protected internal class RuleWithSuffixExceptions : Rule
+        protected class RuleWithSuffixExceptions : Rule
         {
             // TODO: use a more efficient datastructure: automaton?
-            protected internal readonly char[][] m_exceptions;
+            protected readonly char[][] m_exceptions;
 
             public RuleWithSuffixExceptions(string suffix, int min, string replacement, string[]
exceptions) : base(suffix, min, replacement)
             {
@@ -196,12 +192,12 @@ namespace Lucene.Net.Analysis.Pt
         /// <summary>
         /// A step containing a list of rules.
         /// </summary>
-        protected internal class Step
+        protected class Step
         {
             protected internal readonly string m_name;
-            protected internal readonly Rule[] m_rules;
-            protected internal readonly int m_min;
-            protected internal readonly char[][] m_suffixes;
+            protected readonly Rule[] m_rules;
+            protected readonly int m_min;
+            protected readonly char[][] m_suffixes;
 
             /// <summary>
             /// Create a new step </summary>
@@ -278,8 +274,8 @@ namespace Lucene.Net.Analysis.Pt
 
         /// <summary>
         /// Parse a resource file into an RSLP stemmer description. </summary>
-        /// <returns> a Map containing the named Steps in this description. </returns>
-        protected internal static IDictionary<string, Step> Parse(Type clazz, string
resource)
+        /// <returns> a Map containing the named <see cref="Step"/>s in this
description. </returns>
+        protected static IDictionary<string, Step> Parse(Type clazz, string resource)
         {
             IDictionary<string, Step> steps = new Dictionary<string, Step>();
 
@@ -378,7 +374,7 @@ namespace Lucene.Net.Analysis.Pt
 
         private static string ParseString(string s)
         {
-            return s.Substring(1, s.Length - 1 - 1);
+            return s.Substring(1, (s.Length - 1) - 1);
         }
 
         private static string ReadLine(TextReader r)


Mime
View raw message