lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From nightowl...@apache.org
Subject [1/8] lucenenet git commit: Lucene.Net.Analysis.Pattern refactor: member accessibility and documentation comments
Date Fri, 03 Feb 2017 21:06:36 GMT
Repository: lucenenet
Updated Branches:
  refs/heads/api-work 30f14be68 -> f1631b143


Lucene.Net.Analysis.Pattern 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/d60de978
Tree: http://git-wip-us.apache.org/repos/asf/lucenenet/tree/d60de978
Diff: http://git-wip-us.apache.org/repos/asf/lucenenet/diff/d60de978

Branch: refs/heads/api-work
Commit: d60de978e1292a57a87c217aa5fc53f5fe5e9c37
Parents: 30f14be
Author: Shad Storhaug <shad@shadstorhaug.com>
Authored: Sat Feb 4 02:36:22 2017 +0700
Committer: Shad Storhaug <shad@shadstorhaug.com>
Committed: Sat Feb 4 02:36:22 2017 +0700

----------------------------------------------------------------------
 .../Pattern/PatternCaptureGroupFilterFactory.cs |  6 ++-
 .../Pattern/PatternCaptureGroupTokenFilter.cs   | 27 ++++++-------
 .../Pattern/PatternReplaceCharFilter.cs         | 18 ++++-----
 .../Pattern/PatternReplaceCharFilterFactory.cs  |  2 +-
 .../Analysis/Pattern/PatternReplaceFilter.cs    | 16 ++++----
 .../Pattern/PatternReplaceFilterFactory.cs      | 10 ++---
 .../Analysis/Pattern/PatternTokenizer.cs        | 29 +++++++-------
 .../Analysis/Pattern/PatternTokenizerFactory.cs | 40 ++++++++++----------
 8 files changed, 76 insertions(+), 72 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/lucenenet/blob/d60de978/src/Lucene.Net.Analysis.Common/Analysis/Pattern/PatternCaptureGroupFilterFactory.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Pattern/PatternCaptureGroupFilterFactory.cs
b/src/Lucene.Net.Analysis.Common/Analysis/Pattern/PatternCaptureGroupFilterFactory.cs
index a4154db..e446ad2 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Pattern/PatternCaptureGroupFilterFactory.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Pattern/PatternCaptureGroupFilterFactory.cs
@@ -31,17 +31,19 @@ namespace Lucene.Net.Analysis.Pattern
     ///   &lt;/analyzer&gt;
     /// &lt;/fieldType&gt;</code>
     /// </summary>
-    /// <seealso cref= PatternCaptureGroupTokenFilter </seealso>
+    /// <seealso cref="PatternCaptureGroupTokenFilter"/>
     public class PatternCaptureGroupFilterFactory : TokenFilterFactory
     {
         private Regex pattern;
         private bool preserveOriginal = true;
 
-        public PatternCaptureGroupFilterFactory(IDictionary<string, string> args) :
base(args)
+        public PatternCaptureGroupFilterFactory(IDictionary<string, string> args) 
+            : base(args)
         {
             pattern = GetPattern(args, "pattern");
             preserveOriginal = args.ContainsKey("preserve_original") ? bool.Parse(args["preserve_original"])
: true;
         }
+
         public override TokenStream Create(TokenStream input)
         {
             return new PatternCaptureGroupTokenFilter(input, preserveOriginal, pattern);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/d60de978/src/Lucene.Net.Analysis.Common/Analysis/Pattern/PatternCaptureGroupTokenFilter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Pattern/PatternCaptureGroupTokenFilter.cs
b/src/Lucene.Net.Analysis.Common/Analysis/Pattern/PatternCaptureGroupTokenFilter.cs
index 0f7a367..09cca40 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Pattern/PatternCaptureGroupTokenFilter.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Pattern/PatternCaptureGroupTokenFilter.cs
@@ -23,7 +23,7 @@ namespace Lucene.Net.Analysis.Pattern
 	 */
 
     /// <summary>
-    /// CaptureGroup uses Java regexes to emit multiple tokens - one for each capture
+    /// CaptureGroup uses .NET regexes to emit multiple tokens - one for each capture
     /// group in one or more patterns.
     /// 
     /// <para>
@@ -31,7 +31,7 @@ namespace Lucene.Net.Analysis.Pattern
     /// </para>
     /// 
     /// <para>
-    /// <code>"(https?://([a-zA-Z\-_0-9.]+))"</code>
+    /// <c>"(https?://([a-zA-Z\-_0-9.]+))"</c>
     /// </para>
     /// 
     /// <para>
@@ -45,28 +45,27 @@ namespace Lucene.Net.Analysis.Pattern
     /// </para>
     /// <para>
     /// Each pattern is matched as often as it can be, so the pattern
-    /// <code> "(...)"</code>, when matched against <code>"abcdefghi"</code>
would
-    /// produce <code>["abc","def","ghi"]</code>
+    /// <c> "(...)"</c>, when matched against <c>"abcdefghi"</c>
would
+    /// produce <c>["abc","def","ghi"]</c>
     /// </para>
     /// <para>
     /// A camelCaseFilter could be written as:
     /// </para>
     /// <para>
     /// <code>
-    ///   "([A-Z]{2,})",                                 <br />
-    ///   "(?&lt;![A-Z])([A-Z][a-z]+)",                     <br />
-    ///   "(?:^|\\b|(?&lt;=[0-9_])|(?&lt;=[A-Z]{2}))([a-z]+)", <br />
+    ///   "([A-Z]{2,})",                                 
+    ///   "(?&lt;![A-Z])([A-Z][a-z]+)",                     
+    ///   "(?:^|\\b|(?&lt;=[0-9_])|(?&lt;=[A-Z]{2}))([a-z]+)", 
     ///   "([0-9]+)"
     /// </code>
     /// </para>
     /// <para>
-    /// plus if <see cref="#preserveOriginal"/> is true, it would also return
-    /// <code>"camelCaseFilter</code>
+    /// plus if <see cref="preserveOriginal"/> is true, it would also return
+    /// <c>camelCaseFilter</c>
     /// </para>
     /// </summary>
     public sealed class PatternCaptureGroupTokenFilter : TokenFilter
     {
-
         private readonly ICharTermAttribute charTermAttr;
         private readonly IPositionIncrementAttribute posAttr;
         private State state;
@@ -78,6 +77,9 @@ namespace Lucene.Net.Analysis.Pattern
         private int[] currentGroup;
         private int currentMatcher;
 
+        /// <summary>
+        /// Creates a new <see cref="PatternCaptureGroupTokenFilter"/>
+        /// </summary>
         /// <param name="input">
         ///          the input <see cref="TokenStream"/> </param>
         /// <param name="preserveOriginal">
@@ -85,8 +87,8 @@ namespace Lucene.Net.Analysis.Pattern
         ///          patterns matches </param>
         /// <param name="patterns">
         ///          an array of <see cref="Pattern"/> objects to match against each
token </param>
-
-        public PatternCaptureGroupTokenFilter(TokenStream input, bool preserveOriginal, params
Regex[] patterns) : base(input)
+        public PatternCaptureGroupTokenFilter(TokenStream input, bool preserveOriginal, params
Regex[] patterns) 
+            : base(input)
         {
             this.preserveOriginal = preserveOriginal;
             this.matchers = new Match[patterns.Length];
@@ -150,7 +152,6 @@ namespace Lucene.Net.Analysis.Pattern
 
         public override bool IncrementToken()
         {
-
             if (currentMatcher != -1 && NextCapture())
             {
                 Debug.Assert(state != null);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/d60de978/src/Lucene.Net.Analysis.Common/Analysis/Pattern/PatternReplaceCharFilter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Pattern/PatternReplaceCharFilter.cs b/src/Lucene.Net.Analysis.Common/Analysis/Pattern/PatternReplaceCharFilter.cs
index 1ccca48..c2d907b 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Pattern/PatternReplaceCharFilter.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Pattern/PatternReplaceCharFilter.cs
@@ -24,12 +24,12 @@ namespace Lucene.Net.Analysis.Pattern
      */
 
     /// <summary>
-    /// CharFilter that uses a regular expression for the target of replace string.
+    /// <see cref="CharFilter"/> that uses a regular expression for the target of replace
string.
     /// The pattern match will be done in each "block" in char stream.
     /// 
     /// <para>
-    /// ex1) source="aa&nbsp;&nbsp;bb&nbsp;aa&nbsp;bb", pattern="(aa)\\s+(bb)"
replacement="$1#$2"<br/>
-    /// output="aa#bb&nbsp;aa#bb"
+    /// ex1) source="aa  bb aa bb", pattern="(aa)\\s+(bb)" replacement="$1#$2"
+    /// output="aa#bb aa#bb"
     /// </para>
     /// 
     /// NOTE: If you produce a phrase that has different length to source string
@@ -37,9 +37,9 @@ namespace Lucene.Net.Analysis.Pattern
     /// face a trouble.
     /// 
     /// <para>
-    /// ex2) source="aa123bb", pattern="(aa)\\d+(bb)" replacement="$1&nbsp;$2"<br/>
-    /// output="aa&nbsp;bb"<br/>
-    /// and you want to search bb and highlight it, you will get<br/>
+    /// ex2) source="aa123bb", pattern="(aa)\\d+(bb)" replacement="$1 $2"
+    /// output="aa bb"
+    /// and you want to search bb and highlight it, you will get
     /// highlight snippet="aa1&lt;em&gt;23bb&lt;/em&gt;"
     /// </para>
     /// 
@@ -55,7 +55,7 @@ namespace Lucene.Net.Analysis.Pattern
         private TextReader transformedInput;
 
         public PatternReplaceCharFilter(Regex pattern, string replacement, TextReader @in)
-              : base(@in)
+            : base(@in)
         {
             this.pattern = pattern;
             this.replacement = replacement;
@@ -63,7 +63,7 @@ namespace Lucene.Net.Analysis.Pattern
 
         [Obsolete]
         public PatternReplaceCharFilter(Regex pattern, string replacement, int maxBlockChars,
string blockDelimiter, TextReader @in)
-              : this(pattern, replacement, @in)
+            : this(pattern, replacement, @in)
         {
         }
 
@@ -107,7 +107,7 @@ namespace Lucene.Net.Analysis.Pattern
         /// <summary>
         /// Replace pattern in input and mark correction offsets. 
         /// </summary>
-        internal virtual string ProcessPattern(StringBuilder input)
+        private string ProcessPattern(StringBuilder input)
         {
             // LUCENENET TODO: Replacing characters in a StringBuilder is not natively
             // supported in .NET, so this is the approach we are left with.

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/d60de978/src/Lucene.Net.Analysis.Common/Analysis/Pattern/PatternReplaceCharFilterFactory.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Pattern/PatternReplaceCharFilterFactory.cs
b/src/Lucene.Net.Analysis.Common/Analysis/Pattern/PatternReplaceCharFilterFactory.cs
index ffa4121..3e4e645 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Pattern/PatternReplaceCharFilterFactory.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Pattern/PatternReplaceCharFilterFactory.cs
@@ -43,7 +43,7 @@ namespace Lucene.Net.Analysis.Pattern
         private readonly string blockDelimiters;
 
         /// <summary>
-        /// Creates a new PatternReplaceCharFilterFactory </summary>
+        /// Creates a new <see cref="PatternReplaceCharFilterFactory"/> </summary>
         public PatternReplaceCharFilterFactory(IDictionary<string, string> args) :
base(args)
         {
             pattern = GetPattern(args, "pattern");

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/d60de978/src/Lucene.Net.Analysis.Common/Analysis/Pattern/PatternReplaceFilter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Pattern/PatternReplaceFilter.cs b/src/Lucene.Net.Analysis.Common/Analysis/Pattern/PatternReplaceFilter.cs
index 72c0b82..aa687b3 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Pattern/PatternReplaceFilter.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Pattern/PatternReplaceFilter.cs
@@ -21,16 +21,16 @@ namespace Lucene.Net.Analysis.Pattern
      */
 
     /// <summary>
-    /// A TokenFilter which applies a Pattern to each token in the stream,
+    /// A TokenFilter which applies a <see cref="Regex"/> to each token in the stream,
     /// replacing match occurances with the specified replacement string.
     /// 
     /// <para>
     /// <b>Note:</b> Depending on the input and the pattern used and the input
-    /// TokenStream, this TokenFilter may produce Tokens whose text is the empty
+    /// <see cref="TokenStream"/>, this <see cref="TokenFilter"/> may produce
<see cref="Token"/>s whose text is the empty
     /// string.
     /// </para>
     /// </summary>
-    /// <seealso cref= Pattern </seealso>
+    /// <seealso cref="Regex"/>
     public sealed class PatternReplaceFilter : TokenFilter
     {
         private readonly string replacement;
@@ -41,15 +41,15 @@ namespace Lucene.Net.Analysis.Pattern
         /// <summary>
         /// Constructs an instance to replace either the first, or all occurances
         /// </summary>
-        /// <param name="in"> the TokenStream to process </param>
-        /// <param name="pattern"> the pattern (a <see cref="Regex"/> object)
to apply to each Token </param>
-        /// <param name="replacement"> the "replacement string" to substitute, if null
a
+        /// <param name="in"> the <see cref="TokenStream"/> to process </param>
+        /// <param name="pattern"> the pattern (a <see cref="Regex"/> object)
to apply to each <see cref="Token"/> </param>
+        /// <param name="replacement"> the "replacement string" to substitute, if <c>null</c>
a
         ///        blank string will be used. Note that this is not the literal
         ///        string that will be used, '$' and '\' have special meaning. </param>
         /// <param name="all"> if true, all matches will be replaced otherwise just
the first match. </param>
-        /// <seealso cref= Matcher#quoteReplacement </seealso>
+        /// <seealso cref="Regex.Replace(string, string)"/>
         public PatternReplaceFilter(TokenStream @in, Regex pattern, string replacement, bool
all)
-              : base(@in)
+            : base(@in)
         {
             this.replacement = (null == replacement) ? "" : replacement;
             this.all = all;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/d60de978/src/Lucene.Net.Analysis.Common/Analysis/Pattern/PatternReplaceFilterFactory.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Pattern/PatternReplaceFilterFactory.cs
b/src/Lucene.Net.Analysis.Common/Analysis/Pattern/PatternReplaceFilterFactory.cs
index b0e3253..ec5a4ab 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Pattern/PatternReplaceFilterFactory.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Pattern/PatternReplaceFilterFactory.cs
@@ -33,15 +33,15 @@ namespace Lucene.Net.Analysis.Pattern
     ///   &lt;/analyzer&gt;
     /// &lt;/fieldType&gt;</code>
     /// </summary>
-    /// <seealso cref= PatternReplaceFilter </seealso>
+    /// <seealso cref="PatternReplaceFilter"/>
     public class PatternReplaceFilterFactory : TokenFilterFactory
     {
-        internal readonly Regex pattern;
-        internal readonly string replacement;
-        internal readonly bool replaceAll;
+        private readonly Regex pattern;
+        private readonly string replacement;
+        private readonly bool replaceAll;
 
         /// <summary>
-        /// Creates a new PatternReplaceFilterFactory </summary>
+        /// Creates a new <see cref="PatternReplaceFilterFactory"/> </summary>
         public PatternReplaceFilterFactory(IDictionary<string, string> args) : base(args)
         {
             pattern = GetPattern(args, "pattern");

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/d60de978/src/Lucene.Net.Analysis.Common/Analysis/Pattern/PatternTokenizer.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Pattern/PatternTokenizer.cs b/src/Lucene.Net.Analysis.Common/Analysis/Pattern/PatternTokenizer.cs
index d0f80a8..53f58bd 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Pattern/PatternTokenizer.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Pattern/PatternTokenizer.cs
@@ -25,19 +25,19 @@ namespace Lucene.Net.Analysis.Pattern
     /// <summary>
     /// This tokenizer uses regex pattern matching to construct distinct tokens
     /// for the input stream.  It takes two arguments:  "pattern" and "group".
-    /// <p/>
-    /// <ul>
-    /// <li>"pattern" is the regular expression.</li>
-    /// <li>"group" says which group to extract into tokens.</li>
-    ///  </ul>
+    /// <para/>
+    /// <list type="bullet">
+    ///     <item>"pattern" is the regular expression.</item>
+    ///     <item>"group" says which group to extract into tokens.</item>
+    /// </list>
     /// <para>
     /// group=-1 (the default) is equivalent to "split".  In this case, the tokens will
     /// be equivalent to the output from (without empty tokens):
-    /// <see cref="String#split(java.lang.String)"/>
+    /// <see cref="Regex.Replace(string, string)"/>
     /// </para>
     /// <para>
     /// Using group >= 0 selects the matching group as the token.  For example, if you
have:<br/>
-    /// <pre>
+    /// <code>
     ///  pattern = \'([^\']+)\'
     ///  group = 0
     ///  input = aaa 'bbb' 'ccc'
@@ -45,12 +45,11 @@ namespace Lucene.Net.Analysis.Pattern
     /// the output will be two tokens: 'bbb' and 'ccc' (including the ' marks).  With the
same input
     /// but using group=1, the output would be: bbb and ccc (no ' marks)
     /// </para>
-    /// <para>NOTE: This Tokenizer does not output tokens that are of zero length.</para>
+    /// <para>NOTE: This <see cref="Tokenizer"/> does not output tokens that
are of zero length.</para>
     /// </summary>
-    /// <seealso cref= Pattern </seealso>
+    /// <seealso cref="Regex"/>
     public sealed class PatternTokenizer : Tokenizer
     {
-
         private readonly ICharTermAttribute termAtt;
         private readonly IOffsetAttribute offsetAtt;
 
@@ -63,16 +62,16 @@ namespace Lucene.Net.Analysis.Pattern
         private readonly Regex pattern;
 
         /// <summary>
-        /// creates a new PatternTokenizer returning tokens from group (-1 for split functionality)
</summary>
+        /// creates a new <see cref="PatternTokenizer"/> returning tokens from group
(-1 for split functionality) </summary>
         public PatternTokenizer(TextReader input, Regex pattern, int group)
-              : this(AttributeFactory.DEFAULT_ATTRIBUTE_FACTORY, input, pattern, group)
+            : this(AttributeFactory.DEFAULT_ATTRIBUTE_FACTORY, input, pattern, group)
         {
         }
 
         /// <summary>
-        /// creates a new PatternTokenizer returning tokens from group (-1 for split functionality)
</summary>
+        /// creates a new <see cref="PatternTokenizer"/> returning tokens from group
(-1 for split functionality) </summary>
         public PatternTokenizer(AttributeFactory factory, TextReader input, Regex pattern,
int group)
-              : base(factory, input)
+            : base(factory, input)
         {
             this.termAtt = AddAttribute<ICharTermAttribute>();
             this.offsetAtt = AddAttribute<IOffsetAttribute>();
@@ -198,7 +197,7 @@ namespace Lucene.Net.Analysis.Pattern
 
         // TODO: we should see if we can make this tokenizer work without reading
         // the entire document into RAM, perhaps with Matcher.hitEnd/requireEnd ?
-        internal readonly char[] buffer = new char[8192];
+        private readonly char[] buffer = new char[8192];
 
         private void FillBuffer(StringBuilder sb, TextReader input)
         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/d60de978/src/Lucene.Net.Analysis.Common/Analysis/Pattern/PatternTokenizerFactory.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Pattern/PatternTokenizerFactory.cs b/src/Lucene.Net.Analysis.Common/Analysis/Pattern/PatternTokenizerFactory.cs
index 033a3d7..46788d9 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Pattern/PatternTokenizerFactory.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Pattern/PatternTokenizerFactory.cs
@@ -27,23 +27,23 @@ namespace Lucene.Net.Analysis.Pattern
     /// Factory for <see cref="PatternTokenizer"/>.
     /// This tokenizer uses regex pattern matching to construct distinct tokens
     /// for the input stream.  It takes two arguments:  "pattern" and "group".
-    /// <p/>
-    /// <ul>
-    /// <li>"pattern" is the regular expression.</li>
-    /// <li>"group" says which group to extract into tokens.</li>
-    ///  </ul>
+    /// <para/>
+    /// <list type="bullet">
+    ///     <item>"pattern" is the regular expression.</item>
+    ///     <item>"group" says which group to extract into tokens.</item>
+    /// </list>
     /// <para>
     /// group=-1 (the default) is equivalent to "split".  In this case, the tokens will
     /// be equivalent to the output from (without empty tokens):
-    /// <see cref="String#split(java.lang.String)"/>
+    /// <see cref="Regex.Replace(string, string)"/>
     /// </para>
     /// <para>
-    /// Using group >= 0 selects the matching group as the token.  For example, if you
have:<br/>
-    /// <pre>
-    ///  pattern = \'([^\']+)\'
-    ///  group = 0
-    ///  input = aaa 'bbb' 'ccc'
-    /// </pre>
+    /// Using group &gt;= 0 selects the matching group as the token.  For example, if
you have:<br/>
+    /// <code>
+    ///     pattern = \'([^\']+)\'
+    ///     group = 0
+    ///     input = aaa 'bbb' 'ccc'
+    /// </code>
     /// the output will be two tokens: 'bbb' and 'ccc' (including the ' marks).  With the
same input
     /// but using group=1, the output would be: bbb and ccc (no ' marks)
     /// </para>
@@ -54,21 +54,23 @@ namespace Lucene.Net.Analysis.Pattern
     ///   &lt;analyzer&gt;
     ///     &lt;tokenizer class="solr.PatternTokenizerFactory" pattern="\'([^\']+)\'"
group="1"/&gt;
     ///   &lt;/analyzer&gt;
-    /// &lt;/fieldType&gt;</pre> 
+    /// &lt;/fieldType&gt;</code> 
+    /// 
+    /// @since solr1.2
     /// </summary>
-    /// <seealso cref= PatternTokenizer
-    /// @since solr1.2 </seealso>
+    /// <seealso cref="PatternTokenizer"/>
     public class PatternTokenizerFactory : TokenizerFactory
     {
         public const string PATTERN = "pattern";
         public const string GROUP = "group";
 
-        protected internal readonly Regex m_pattern;
-        protected internal readonly int m_group;
+        protected readonly Regex m_pattern;
+        protected readonly int m_group;
 
         /// <summary>
-        /// Creates a new PatternTokenizerFactory </summary>
-        public PatternTokenizerFactory(IDictionary<string, string> args) : base(args)
+        /// Creates a new <see cref="PatternTokenizerFactory"/> </summary>
+        public PatternTokenizerFactory(IDictionary<string, string> args) 
+            : base(args)
         {
             m_pattern = GetPattern(args, PATTERN);
             m_group = GetInt(args, GROUP, -1);


Mime
View raw message