BREAKING: De-nest AttributeSource.AttributeFactory, #1145 (#1147)

Author: paulirwin

src/Lucene.Net.Analysis.Common/Analysis/Ar/ArabicLetterTokenizer.cs

@@ -41,14 +41,14 @@ namespace Lucene.Net.Analysis.Ar
     /// </list>
     /// </para>
     /// </summary>
-    /// @deprecated (3.1) Use <see cref="Standard.StandardTokenizer"/> instead. 
+    /// @deprecated (3.1) Use <see cref="Standard.StandardTokenizer"/> instead.
     [Obsolete("(3.1) Use StandardTokenizer instead.")]
     public class ArabicLetterTokenizer : LetterTokenizer
     {
         /// <summary>
         /// Construct a new ArabicLetterTokenizer. </summary>
         /// <param name="matchVersion"> <see cref="LuceneVersion"/>
-        /// to match 
+        /// to match
         /// </param>
         /// <param name="in">
         ///          the input to split up into tokens </param>
@@ -59,7 +59,7 @@ public ArabicLetterTokenizer(LuceneVersion matchVersion, TextReader @in)
 
         /// <summary>
         /// Construct a new <see cref="ArabicLetterTokenizer"/> using a given
-        /// <see cref="AttributeSource.AttributeFactory"/>. 
+        /// <see cref="AttributeFactory"/>.
         /// </summary>
         /// <param name="matchVersion">
         ///         Lucene version to match - See
@@ -82,4 +82,4 @@ protected override bool IsTokenChar(int c)
             return base.IsTokenChar(c) || Character.GetType(c) == UnicodeCategory.NonSpacingMark;
         }
     }
-}
+}

src/Lucene.Net.Analysis.Common/Analysis/Ar/ArabicLetterTokenizerFactory.cs

@@ -27,7 +27,7 @@ namespace Lucene.Net.Analysis.Ar
     /// <summary>
     /// Factory for <see cref="ArabicLetterTokenizer"/> </summary>
     /// @deprecated (3.1) Use StandardTokenizerFactory instead.
-    ///  
+    ///
     [Obsolete("(3.1) Use StandardTokenizerFactory instead.")]
     public class ArabicLetterTokenizerFactory : TokenizerFactory
     {
@@ -44,9 +44,9 @@ public ArabicLetterTokenizerFactory(IDictionary<string, string> args)
             }
         }
 
-        public override Tokenizer Create(AttributeSource.AttributeFactory factory, TextReader input)
+        public override Tokenizer Create(AttributeFactory factory, TextReader input)
         {
             return new ArabicLetterTokenizer(m_luceneMatchVersion, factory, input);
         }
     }
-}
+}

src/Lucene.Net.Analysis.Common/Analysis/Cjk/CJKTokenizer.cs

@@ -1,6 +1,7 @@
 // Lucene version compatibility level 4.8.1
 using J2N;
 using Lucene.Net.Analysis.TokenAttributes;
+using Lucene.Net.Util;
 using System;
 using System.IO;
 using System.Text.RegularExpressions;
@@ -26,7 +27,7 @@ namespace Lucene.Net.Analysis.Cjk
 
     /// <summary>
     /// CJKTokenizer is designed for Chinese, Japanese, and Korean languages.
-    /// <para>  
+    /// <para>
     /// The tokens returned are every two adjacent characters with overlap match.
     /// </para>
     /// <para>
@@ -42,7 +43,7 @@ namespace Lucene.Net.Analysis.Cjk
     /// please search  <a
     /// href="http://www.google.com/search?q=word+chinese+segment">google</a>
     /// </summary>
-    /// @deprecated Use StandardTokenizer, CJKWidthFilter, CJKBigramFilter, and LowerCaseFilter instead. 
+    /// @deprecated Use StandardTokenizer, CJKWidthFilter, CJKBigramFilter, and LowerCaseFilter instead.
     [Obsolete("Use StandardTokenizer, CJKWidthFilter, CJKBigramFilter, and LowerCaseFilter instead.")]
     public sealed class CJKTokenizer : Tokenizer
     {
@@ -96,7 +97,7 @@ public sealed class CJKTokenizer : Tokenizer
         private int dataLen = 0;
 
         /// <summary>
-        /// character buffer, store the characters which are used to compose 
+        /// character buffer, store the characters which are used to compose
         /// the returned Token
         /// </summary>
         private readonly char[] buffer = new char[MAX_WORD_LEN];
@@ -163,14 +164,14 @@ public override bool IncrementToken()
         {
             ClearAttributes();
 
-            // how many character(s) has been stored in buffer 
+            // how many character(s) has been stored in buffer
 
             while (true) // loop until we find a non-empty token
             {
 
                 int length = 0;
 
-                // the position used to create Token 
+                // the position used to create Token
                 int start = offset;
 
                 while (true) // loop until we've found a full token
@@ -373,4 +374,4 @@ public override void Reset()
             tokenType = WORD_TYPE;
         }
     }
-}
+}

src/Lucene.Net.Analysis.Common/Analysis/Cjk/CJKTokenizerFactory.cs

@@ -26,7 +26,7 @@ namespace Lucene.Net.Analysis.Cjk
 
 
     /// <summary>
-    /// Factory for <see cref="CJKTokenizer"/>. 
+    /// Factory for <see cref="CJKTokenizer"/>.
     /// <code>
     /// &lt;fieldType name="text_cjk" class="solr.TextField" positionIncrementGap="100"&gt;
     ///   &lt;analyzer&gt;
@@ -35,7 +35,7 @@ namespace Lucene.Net.Analysis.Cjk
     /// &lt;/fieldType&gt;
     /// </code>
     /// </summary>
-    /// @deprecated Use <see cref="CJKBigramFilterFactory"/> instead. 
+    /// @deprecated Use <see cref="CJKBigramFilterFactory"/> instead.
     [Obsolete("Use CJKBigramFilterFactory instead.")]
     public class CJKTokenizerFactory : TokenizerFactory
     {
@@ -49,9 +49,9 @@ public CJKTokenizerFactory(IDictionary<string, string> args) : base(args)
             }
         }
 
-        public override Tokenizer Create(AttributeSource.AttributeFactory factory, TextReader @in)
+        public override Tokenizer Create(AttributeFactory factory, TextReader @in)
         {
             return new CJKTokenizer(factory, @in);
         }
     }
-}
+}

src/Lucene.Net.Analysis.Common/Analysis/Cn/ChineseTokenizer.cs

@@ -1,5 +1,6 @@
 // Lucene version compatibility level 4.8.1
 using Lucene.Net.Analysis.TokenAttributes;
+using Lucene.Net.Util;
 using System;
 using System.Globalization;
 using System.IO;
@@ -25,7 +26,7 @@ namespace Lucene.Net.Analysis.Cn
 
     /// <summary>
     /// Tokenize Chinese text as individual chinese characters.
-    /// 
+    ///
     /// <para>
     /// The difference between <see cref="ChineseTokenizer"/> and
     /// <see cref="Cjk.CJKTokenizer"/> is that they have different
@@ -46,10 +47,10 @@ namespace Lucene.Net.Analysis.Cn
     /// The problem is that when searching for C1, C1C2, C1C3,
     /// C4C2, C1C2C3 ... the <see cref="ChineseTokenizer"/> works, but the
     /// <see cref="Cjk.CJKTokenizer"/> will not work.
-    /// </para> 
+    /// </para>
     /// </summary>
     /// @deprecated (3.1) Use <see cref="Standard.StandardTokenizer"/> instead, which has the same functionality.
-    /// This filter will be removed in Lucene 5.0 
+    /// This filter will be removed in Lucene 5.0
     [Obsolete("(3.1) Use StandardTokenizer instead, which has the same functionality.")]
     public sealed class ChineseTokenizer : Tokenizer
     {
@@ -186,4 +187,4 @@ public override void Reset()
             offset = bufferIndex = dataLen = 0;
         }
     }
-}
+}

src/Lucene.Net.Analysis.Common/Analysis/Cn/ChineseTokenizerFactory.cs

@@ -27,7 +27,7 @@ namespace Lucene.Net.Analysis.Cn
     /// <summary>
     /// Factory for <see cref="ChineseTokenizer"/>
     /// </summary>
-    /// @deprecated Use <see cref="Standard.StandardTokenizerFactory"/> instead. 
+    /// @deprecated Use <see cref="Standard.StandardTokenizerFactory"/> instead.
     [Obsolete("Use StandardTokenizerFactory instead.")]
     public class ChineseTokenizerFactory : TokenizerFactory
     {
@@ -42,9 +42,9 @@ public ChineseTokenizerFactory(IDictionary<string, string> args)
             }
         }
 
-        public override Tokenizer Create(AttributeSource.AttributeFactory factory, TextReader input)
+        public override Tokenizer Create(AttributeFactory factory, TextReader input)
         {
             return new ChineseTokenizer(factory, input);
         }
     }
-}
+}

src/Lucene.Net.Analysis.Common/Analysis/Core/KeywordTokenizer.cs

@@ -55,7 +55,7 @@ public KeywordTokenizer(TextReader input, int bufferSize)
             termAtt.ResizeBuffer(bufferSize);
         }
 
-        public KeywordTokenizer(AttributeSource.AttributeFactory factory, TextReader input, int bufferSize)
+        public KeywordTokenizer(AttributeFactory factory, TextReader input, int bufferSize)
             : base(factory, input)
         {
             termAtt = AddAttribute<ICharTermAttribute>();
@@ -100,7 +100,7 @@ public override sealed bool IncrementToken()
         public override sealed void End()
         {
             base.End();
-            // set final offset 
+            // set final offset
             offsetAtt.SetOffset(finalOffset, finalOffset);
         }
 
@@ -110,4 +110,4 @@ public override void Reset()
             this.done = false;
         }
     }
-}
+}

src/Lucene.Net.Analysis.Common/Analysis/Core/KeywordTokenizerFactory.cs

@@ -25,14 +25,14 @@ namespace Lucene.Net.Analysis.Core
      */
 
     /// <summary>
-    /// Factory for <see cref="KeywordTokenizer"/>. 
+    /// Factory for <see cref="KeywordTokenizer"/>.
     /// <code>
     /// &lt;fieldType name="text_keyword" class="solr.TextField" positionIncrementGap="100"&gt;
     ///   &lt;analyzer&gt;
     ///     &lt;tokenizer class="solr.KeywordTokenizerFactory"/&gt;
     ///   &lt;/analyzer&gt;
     /// &lt;/fieldType&gt;
-    /// </code> 
+    /// </code>
     /// </summary>
     public class KeywordTokenizerFactory : TokenizerFactory
     {
@@ -47,9 +47,9 @@ public KeywordTokenizerFactory(IDictionary<string, string> args)
             }
         }
 
-        public override Tokenizer Create(AttributeSource.AttributeFactory factory, TextReader input)
+        public override Tokenizer Create(AttributeFactory factory, TextReader input)
         {
             return new KeywordTokenizer(factory, input, KeywordTokenizer.DEFAULT_BUFFER_SIZE);
         }
     }
-}
+}

src/Lucene.Net.Analysis.Common/Analysis/Core/LetterTokenizer.cs

@@ -57,15 +57,15 @@ public LetterTokenizer(LuceneVersion matchVersion, TextReader @in)
 
         /// <summary>
         /// Construct a new <see cref="LetterTokenizer"/> using a given
-        /// <see cref="AttributeSource.AttributeFactory"/>.
+        /// <see cref="AttributeFactory"/>.
         /// </summary>
         /// <param name="matchVersion">
         ///          <see cref="LuceneVersion"/> to match</param>
         /// <param name="factory">
         ///          the attribute factory to use for this <see cref="Tokenizer"/> </param>
         /// <param name="in">
         ///          the input to split up into tokens </param>
-        public LetterTokenizer(LuceneVersion matchVersion, AttributeSource.AttributeFactory factory, TextReader @in)
+        public LetterTokenizer(LuceneVersion matchVersion, AttributeFactory factory, TextReader @in)
             : base(matchVersion, factory, @in)
         {
         }
@@ -79,4 +79,4 @@ protected override bool IsTokenChar(int c)
             return Character.IsLetter(c);
         }
     }
-}
+}

src/Lucene.Net.Analysis.Common/Analysis/Core/LetterTokenizerFactory.cs

@@ -25,7 +25,7 @@ namespace Lucene.Net.Analysis.Core
      */
 
     /// <summary>
-    /// Factory for <see cref="LetterTokenizer"/>. 
+    /// Factory for <see cref="LetterTokenizer"/>.
     /// <code>
     /// &lt;fieldType name="text_letter" class="solr.TextField" positionIncrementGap="100"&gt;
     ///   &lt;analyzer&gt;
@@ -48,9 +48,9 @@ public LetterTokenizerFactory(IDictionary<string, string> args)
             }
         }
 
-        public override Tokenizer Create(AttributeSource.AttributeFactory factory, TextReader input)
+        public override Tokenizer Create(AttributeFactory factory, TextReader input)
         {
             return new LetterTokenizer(m_luceneMatchVersion, factory, input);
         }
     }
-}
+}

src/Lucene.Net.Analysis.Common/Analysis/Core/LowerCaseTokenizer.cs

@@ -60,15 +60,15 @@ public LowerCaseTokenizer(LuceneVersion matchVersion, TextReader @in)
 
         /// <summary>
         /// Construct a new <see cref="LowerCaseTokenizer"/> using a given
-        /// <see cref="AttributeSource.AttributeFactory"/>.
+        /// <see cref="AttributeFactory"/>.
         /// </summary>
         /// <param name="matchVersion">
         ///          <see cref="LuceneVersion"/> to match </param>
         /// <param name="factory">
         ///          the attribute factory to use for this <see cref="Tokenizer"/> </param>
         /// <param name="in">
         ///          the input to split up into tokens </param>
-        public LowerCaseTokenizer(LuceneVersion matchVersion, AttributeSource.AttributeFactory factory, TextReader @in)
+        public LowerCaseTokenizer(LuceneVersion matchVersion, AttributeFactory factory, TextReader @in)
             : base(matchVersion, factory, @in)
         {
         }
@@ -82,4 +82,4 @@ protected override int Normalize(int c)
             return Character.ToLower(c, CultureInfo.InvariantCulture); // LUCENENET specific - need to use invariant culture to match Java
         }
     }
-}
+}

src/Lucene.Net.Analysis.Common/Analysis/Core/LowerCaseTokenizerFactory.cs

@@ -25,7 +25,7 @@ namespace Lucene.Net.Analysis.Core
      */
 
     /// <summary>
-    /// Factory for <see cref="LowerCaseTokenizer"/>. 
+    /// Factory for <see cref="LowerCaseTokenizer"/>.
     /// <code>
     /// &lt;fieldType name="text_lwrcase" class="solr.TextField" positionIncrementGap="100"&gt;
     ///   &lt;analyzer&gt;
@@ -48,7 +48,7 @@ public LowerCaseTokenizerFactory(IDictionary<string, string> args)
             }
         }
 
-        public override Tokenizer Create(AttributeSource.AttributeFactory factory, TextReader input)
+        public override Tokenizer Create(AttributeFactory factory, TextReader input)
         {
             return new LowerCaseTokenizer(m_luceneMatchVersion, factory, input);
         }
@@ -58,4 +58,4 @@ public virtual AbstractAnalysisFactory GetMultiTermComponent()
             return new LowerCaseFilterFactory(new Dictionary<string, string>(OriginalArgs));
         }
     }
-}
+}

src/Lucene.Net.Analysis.Common/Analysis/Core/WhitespaceTokenizer.cs

@@ -38,7 +38,7 @@ namespace Lucene.Net.Analysis.Core
     /// </summary>
     public sealed class WhitespaceTokenizer : CharTokenizer
     {
-        /// Construct a new <see cref="WhitespaceTokenizer"/>. 
+        /// Construct a new <see cref="WhitespaceTokenizer"/>.
         /// <param name="matchVersion"> <see cref="LuceneVersion"/> to match</param>
         /// <param name="in">
         ///          the input to split up into tokens </param>
@@ -49,7 +49,7 @@ public WhitespaceTokenizer(LuceneVersion matchVersion, TextReader @in)
 
         /// <summary>
         /// Construct a new <see cref="WhitespaceTokenizer"/> using a given
-        /// <see cref="AttributeSource.AttributeFactory"/>.
+        /// <see cref="AttributeFactory"/>.
         /// </summary>
         /// <param name="matchVersion"><see cref="LuceneVersion"/> to match</param>
         /// <param name="factory">
@@ -70,4 +70,4 @@ protected override bool IsTokenChar(int c)
             return !Character.IsWhiteSpace(c);
         }
     }
-}
+}