You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucenenet.apache.org by ni...@apache.org on 2021/02/20 15:12:33 UTC
[lucenenet] 01/03: Improved suffix naming of class names for
classes ported from java anonymous classes. For example classes that had a
AnonymousInnerClassHelper name suffix now have a AnonymousClass name
suffix. And ones that had a AnonymousHelper suffix now have a
AnonymousClass suffix. etc.
This is an automated email from the ASF dual-hosted git repository.
nightowl888 pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/lucenenet.git
commit a1d21e65d4463116bff805cddb4bab4d2ebb08ba
Author: Ron Clabo <ro...@GiftOasis.com>
AuthorDate: Fri Feb 19 17:52:00 2021 -0500
Improved suffix naming of class names for classes ported from java anonymous classes. For example classes that had a AnonymousInnerClassHelper name suffix now have a AnonymousClass name suffix. And ones that had a AnonymousHelper suffix now have a AnonymousClass suffix. etc.
---
CHANGES.txt | 2 +-
.../PrefixAndSuffixAwareTokenFilter.cs | 12 +--
.../Analysis/NGram/NGramTokenFilter.cs | 8 +-
.../Analysis/Sinks/TeeSinkTokenFilter.cs | 4 +-
.../Analysis/Standard/ClassicAnalyzer.cs | 6 +-
.../Analysis/Standard/StandardAnalyzer.cs | 6 +-
.../Analysis/Standard/UAX29URLEmailAnalyzer.cs | 6 +-
.../Analysis/Util/CharArrayIterator.cs | 8 +-
.../Icu/Segmentation/ICUTokenizerFactory.cs | 6 +-
.../Language/Bm/Rule.cs | 6 +-
.../ByTask/Feeds/DemoHTMLParser.cs | 6 +-
.../ByTask/Feeds/SpatialDocMaker.cs | 18 ++---
.../ByTask/Tasks/SearchTravRetHighlightTask.cs | 6 +-
.../Tasks/SearchTravRetVectorHighlightTask.cs | 6 +-
.../ByTask/Utils/AnalyzerFactory.cs | 6 +-
.../Quality/Utils/DocNameExtractor.cs | 6 +-
.../DiskDV/DiskDocValuesFormat.cs | 6 +-
.../Memory/DirectDocValuesConsumer.cs | 6 +-
.../Memory/DirectDocValuesProducer.cs | 42 +++++-----
.../Memory/MemoryDocValuesConsumer.cs | 6 +-
.../Memory/MemoryDocValuesProducer.cs | 42 +++++-----
.../Memory/MemoryPostingsFormat.cs | 12 +--
.../SimpleText/SimpleTextDocValuesReader.cs | 36 ++++-----
src/Lucene.Net.Facet/DrillSidewaysQuery.cs | 6 +-
src/Lucene.Net.Facet/FacetsCollector.cs | 6 +-
src/Lucene.Net.Facet/Range/DoubleRange.cs | 22 +++---
src/Lucene.Net.Facet/Range/LongRange.cs | 22 +++---
.../Taxonomy/CachedOrdinalsReader.cs | 6 +-
.../Taxonomy/DocValuesOrdinalsReader.cs | 6 +-
.../Taxonomy/TaxonomyFacetSumValueSource.cs | 6 +-
.../PostingsHighlight/MultiTermHighlighting.cs | 22 +++---
.../PostingsHighlight/Passage.cs | 6 +-
.../PostingsHighlight/PostingsHighlighter.cs | 10 +--
.../VectorHighlight/BaseFragmentsBuilder.cs | 6 +-
src/Lucene.Net.Join/TermsIncludingScoreQuery.cs | 6 +-
.../MemoryIndex.MemoryIndexReader.cs | 12 +--
src/Lucene.Net.Memory/MemoryIndex.cs | 14 ++--
.../Index/Sorter/BlockJoinComparatorSource.cs | 6 +-
src/Lucene.Net.Misc/Index/Sorter/Sorter.cs | 18 ++---
.../Index/Sorter/SortingAtomicReader.cs | 6 +-
.../Index/Sorter/SortingMergePolicy.cs | 6 +-
src/Lucene.Net.Queries/BoostingQuery.cs | 14 ++--
.../Function/ValueSources/ByteFieldSource.cs | 6 +-
.../Function/ValueSources/BytesRefFieldSource.cs | 12 +--
.../Function/ValueSources/ConstValueSource.cs | 6 +-
.../Function/ValueSources/DefFunction.cs | 6 +-
.../ValueSources/DoubleConstValueSource.cs | 6 +-
.../Function/ValueSources/DoubleFieldSource.cs | 6 +-
.../Function/ValueSources/DualFloatFunction.cs | 6 +-
.../Function/ValueSources/EnumFieldSource.cs | 6 +-
.../Function/ValueSources/FloatFieldSource.cs | 6 +-
.../Function/ValueSources/IfFunction.cs | 6 +-
.../Function/ValueSources/IntFieldSource.cs | 6 +-
.../ValueSources/JoinDocFreqValueSource.cs | 6 +-
.../Function/ValueSources/LinearFloatFunction.cs | 6 +-
.../Function/ValueSources/LiteralValueSource.cs | 6 +-
.../Function/ValueSources/LongFieldSource.cs | 6 +-
.../Function/ValueSources/MultiBoolFunction.cs | 6 +-
.../Function/ValueSources/MultiFloatFunction.cs | 6 +-
.../Function/ValueSources/NormValueSource.cs | 6 +-
.../Function/ValueSources/OrdFieldSource.cs | 6 +-
.../Function/ValueSources/RangeMapFloatFunction.cs | 6 +-
.../ValueSources/ReciprocalFloatFunction.cs | 6 +-
.../Function/ValueSources/ReverseOrdFieldSource.cs | 6 +-
.../Function/ValueSources/ScaleFloatFunction.cs | 6 +-
.../Function/ValueSources/ShortFieldSource.cs | 6 +-
.../Function/ValueSources/SimpleBoolFunction.cs | 6 +-
.../Function/ValueSources/SimpleFloatFunction.cs | 6 +-
.../ValueSources/SumTotalTermFreqValueSource.cs | 6 +-
.../Function/ValueSources/TFValueSource.cs | 10 +--
.../Function/ValueSources/TermFreqValueSource.cs | 10 +--
.../ValueSources/TotalTermFreqValueSource.cs | 6 +-
.../Function/ValueSources/VectorValueSource.cs | 12 +--
src/Lucene.Net.Queries/TermFilter.cs | 6 +-
src/Lucene.Net.Queries/TermsFilter.cs | 12 +--
.../Queries/SortedSetSortField.cs | 6 +-
.../Prefix/ContainsPrefixTreeFilter.cs | 8 +-
.../Prefix/IntersectsPrefixTreeFilter.cs | 8 +-
.../Prefix/WithinPrefixTreeFilter.cs | 8 +-
.../Serialized/SerializedDVStrategy.cs | 24 +++---
.../Util/DistanceToShapeValueSource.cs | 6 +-
.../Util/ShapePredicateValueSource.cs | 6 +-
.../Suggest/Analyzing/AnalyzingInfixSuggester.cs | 6 +-
.../Suggest/Analyzing/AnalyzingSuggester.cs | 6 +-
.../Suggest/Analyzing/FreeTextSuggester.cs | 12 +--
.../Analysis/CollationTestBase.cs | 6 +-
.../Analysis/LookaheadTokenFilter.cs | 6 +-
.../Compressing/Dummy/DummyCompressingCodec.cs | 14 ++--
.../Codecs/Lucene3x/PreFlexRWPostingsFormat.cs | 6 +-
.../Codecs/Lucene3x/PreFlexRWTermVectorsFormat.cs | 6 +-
.../Codecs/Lucene40/Lucene40RWCodec.cs | 4 +-
.../Codecs/Lucene41/Lucene41RWCodec.cs | 4 +-
.../Codecs/Lucene42/Lucene42DocValuesConsumer.cs | 6 +-
.../Codecs/Lucene42/Lucene42RWCodec.cs | 4 +-
.../Codecs/Lucene45/Lucene45RWCodec.cs | 4 +-
.../Codecs/MissingOrdRemapper.cs | 36 ++++-----
.../MockFixedIntBlockPostingsFormat.cs | 18 ++---
.../MockVariableIntBlockPostingsFormat.cs | 18 ++---
.../Codecs/MockRandom/MockRandomPostingsFormat.cs | 6 +-
.../Codecs/RAMOnly/RAMOnlyPostingsFormat.cs | 6 +-
.../Index/BaseDocValuesFormatTestCase.cs | 34 ++++----
.../Index/BaseMergePolicyTestCase.cs | 6 +-
.../Index/BaseStoredFieldsFormatTestCase.cs | 6 +-
.../Index/BaseTermVectorsFormatTestCase.cs | 6 +-
.../Index/FieldFilterAtomicReader.cs | 6 +-
.../Index/RandomIndexWriter.cs | 34 ++++----
.../Index/ThreadedIndexingAndSearchingTestCase.cs | 24 +++---
.../Search/AssertingIndexSearcher.cs | 6 +-
src/Lucene.Net.TestFramework/Search/QueryUtils.cs | 18 ++---
.../Store/MockDirectoryWrapper.cs | 6 +-
.../Util/LuceneTestCase.cs | 6 +-
.../Util/TestRuleAssertionsRequired.cs | 6 +-
.../Util/TestRuleFieldCacheSanity.cs | 6 +-
.../Util/TestRuleIgnoreAfterMaxFailures.cs | 6 +-
.../Util/TestRuleIgnoreTestSuites.cs | 6 +-
.../Util/TestRuleMarkFailure.cs | 6 +-
.../Util/TestRuleSetupAndRestoreClassEnv.cs | 6 +-
.../Util/TestRuleSetupTeardownChained.cs | 6 +-
.../Util/TestRuleStoreClassName.cs | 6 +-
.../Util/TestRuleThreadAndTestName.cs | 6 +-
.../Util/TestSecurityManager.cs | 6 +-
src/Lucene.Net.TestFramework/Util/TestUtil.cs | 22 +++---
.../Analysis/Core/TestBugInSomething.cs | 6 +-
.../Analysis/Core/TestFactories.cs | 6 +-
.../Analysis/Core/TestRandomChains.cs | 18 ++---
.../TestRemoveDuplicatesTokenFilter.cs | 6 +-
.../Analysis/NGram/NGramTokenizerTest.cs | 6 +-
.../Analysis/Sinks/TestTeeSinkTokenFilter.cs | 8 +-
.../Analysis/Synonym/TestSynonymMap.cs | 4 +-
.../Analysis/Util/TestAnalysisSPILoader.cs | 6 +-
.../Analysis/Util/TestBufferedCharFilter.cs | 6 +-
.../Analysis/Util/TestCharTokenizers.cs | 26 +++----
.../Analysis/Icu/Segmentation/TestICUTokenizer.cs | 8 +-
.../ByTask/Tasks/CountingHighlighterTestTask.cs | 6 +-
.../ByTask/Tasks/WriteLineDocTaskTest.cs | 6 +-
.../Range/TestRangeFacetCounts.cs | 32 ++++----
.../Taxonomy/Directory/TestAddTaxonomy.cs | 12 +--
.../Directory/TestConcurrentFacetedIndexing.cs | 12 +--
.../Directory/TestDirectoryTaxonomyReader.cs | 22 +++---
.../Directory/TestDirectoryTaxonomyWriter.cs | 10 +--
.../Taxonomy/TestCachedOrdinalsReader.cs | 6 +-
.../Taxonomy/TestSearcherTaxonomyManager.cs | 6 +-
.../Taxonomy/TestTaxonomyCombined.cs | 6 +-
.../Taxonomy/TestTaxonomyFacetCounts.cs | 6 +-
.../Taxonomy/TestTaxonomyFacetSumValueSource.cs | 14 ++--
src/Lucene.Net.Tests.Facet/TestDrillSideways.cs | 30 ++++----
src/Lucene.Net.Tests.Facet/TestFacetsConfig.cs | 6 +-
.../Highlight/HighlighterPhraseTest.cs | 6 +-
.../Highlight/HighlighterTest.cs | 22 +++---
.../Highlight/OffsetLimitTokenFilterTest.cs | 4 +-
.../VectorHighlight/FastVectorHighlighterTest.cs | 6 +-
.../VectorHighlight/FieldQueryTest.cs | 8 +-
.../VectorHighlight/IndexTimeSynonymTest.cs | 6 +-
src/Lucene.Net.Tests.Join/TestJoinUtil.cs | 34 ++++----
.../TestCustomScoreQuery.cs | 18 ++---
.../IndexAndTaxonomyReplicationClientTest.cs | 12 +--
.../IndexReplicationClientTest.cs | 14 ++--
.../QueryEqualsHashCodeTest.cs | 18 ++---
.../Analysis/TestMockAnalyzer.cs | 6 +-
.../Analysis/TestCachingTokenFilter.cs | 6 +-
src/Lucene.Net.Tests/Analysis/TestMockAnalyzer.cs | 12 +--
.../TokenAttributes/TestCharTermAttributeImpl.cs | 6 +-
.../TestCompressingStoredFieldsFormat.cs | 6 +-
.../Codecs/PerField/TestPerFieldDocValuesFormat.cs | 6 +-
.../Codecs/PerField/TestPerFieldPostingsFormat2.cs | 12 +--
src/Lucene.Net.Tests/Index/TestAddIndexes.cs | 6 +-
src/Lucene.Net.Tests/Index/TestBagOfPositions.cs | 6 +-
src/Lucene.Net.Tests/Index/TestBagOfPostings.cs | 6 +-
.../Index/TestBinaryDocValuesUpdates.cs | 24 +++---
src/Lucene.Net.Tests/Index/TestCodecs.cs | 6 +-
.../Index/TestConcurrentMergeScheduler.cs | 6 +-
src/Lucene.Net.Tests/Index/TestDirectoryReader.cs | 6 +-
.../Index/TestDirectoryReaderReopen.cs | 30 ++++----
.../Index/TestDocInverterPerFieldErrorInfo.cs | 6 +-
.../Index/TestDocValuesIndexing.cs | 6 +-
.../Index/TestDocValuesWithThreads.cs | 12 +--
src/Lucene.Net.Tests/Index/TestDocumentWriter.cs | 24 +++---
.../Index/TestDocumentsWriterDeleteQueue.cs | 6 +-
.../Index/TestDocumentsWriterStallControl.cs | 12 +--
.../Index/TestForceMergeForever.cs | 6 +-
src/Lucene.Net.Tests/Index/TestIndexCommit.cs | 12 +--
src/Lucene.Net.Tests/Index/TestIndexReaderClose.cs | 6 +-
src/Lucene.Net.Tests/Index/TestIndexWriter.cs | 24 +++---
.../Index/TestIndexWriterCommit.cs | 6 +-
.../Index/TestIndexWriterDelete.cs | 24 +++---
.../Index/TestIndexWriterExceptions.cs | 52 ++++++-------
.../Index/TestIndexWriterMerging.cs | 6 +-
.../Index/TestIndexWriterOnJRECrash.cs | 12 +--
.../Index/TestIndexWriterReader.cs | 36 ++++-----
.../Index/TestIndexWriterWithThreads.cs | 8 +-
src/Lucene.Net.Tests/Index/TestIndexableField.cs | 20 ++---
.../Index/TestMixedDocValuesUpdates.cs | 6 +-
src/Lucene.Net.Tests/Index/TestNeverDelete.cs | 6 +-
.../Index/TestNumericDocValuesUpdates.cs | 24 +++---
src/Lucene.Net.Tests/Index/TestOmitTf.cs | 30 ++++----
.../Index/TestParallelCompositeReader.cs | 14 ++--
src/Lucene.Net.Tests/Index/TestPayloads.cs | 6 +-
.../Index/TestPersistentSnapshotDeletionPolicy.cs | 6 +-
.../Index/TestSnapshotDeletionPolicy.cs | 12 +--
src/Lucene.Net.Tests/Index/TestStressNRT.cs | 12 +--
src/Lucene.Net.Tests/Index/TestTermdocPerf.cs | 6 +-
.../Index/TestThreadedForceMerge.cs | 6 +-
.../Search/Payloads/TestPayloadExplanations.cs | 6 +-
.../Search/Spans/TestFieldMaskingSpanQuery.cs | 6 +-
src/Lucene.Net.Tests/Search/Spans/TestSpans.cs | 6 +-
src/Lucene.Net.Tests/Search/TestAutomatonQuery.cs | 6 +-
src/Lucene.Net.Tests/Search/TestBoolean2.cs | 6 +-
.../Search/TestBooleanMinShouldMatch.cs | 18 ++---
src/Lucene.Net.Tests/Search/TestBooleanOr.cs | 6 +-
src/Lucene.Net.Tests/Search/TestBooleanQuery.cs | 6 +-
src/Lucene.Net.Tests/Search/TestBooleanScorer.cs | 30 ++++----
.../Search/TestCachingCollector.cs | 6 +-
.../Search/TestCachingWrapperFilter.cs | 26 +++----
.../Search/TestComplexExplanations.cs | 6 +-
src/Lucene.Net.Tests/Search/TestConjunctions.cs | 12 +--
.../Search/TestConstantScoreQuery.cs | 12 +--
.../Search/TestControlledRealTimeReopenThread.cs | 36 ++++-----
src/Lucene.Net.Tests/Search/TestDocBoost.cs | 6 +-
src/Lucene.Net.Tests/Search/TestDocIdSet.cs | 48 ++++++------
.../Search/TestDocValuesScoring.cs | 12 +--
.../Search/TestEarlyTermination.cs | 6 +-
.../Search/TestElevationComparator.cs | 6 +-
src/Lucene.Net.Tests/Search/TestFieldCache.cs | 12 +--
src/Lucene.Net.Tests/Search/TestFilteredQuery.cs | 62 +++++++--------
src/Lucene.Net.Tests/Search/TestLiveFieldValues.cs | 16 ++--
src/Lucene.Net.Tests/Search/TestMinShouldMatch2.cs | 6 +-
.../Search/TestMultiPhraseQuery.cs | 6 +-
.../Search/TestMultiTermConstantScore.cs | 6 +-
.../Search/TestMultiTermQueryRewrites.cs | 14 ++--
src/Lucene.Net.Tests/Search/TestPhraseQuery.cs | 6 +-
.../Search/TestPositionIncrement.cs | 12 +--
src/Lucene.Net.Tests/Search/TestQueryRescorer.cs | 32 ++++----
src/Lucene.Net.Tests/Search/TestRegexpQuery.cs | 6 +-
.../Search/TestSameScoresWithThreads.cs | 6 +-
src/Lucene.Net.Tests/Search/TestScorerPerf.cs | 6 +-
.../Search/TestSearchWithThreads.cs | 6 +-
src/Lucene.Net.Tests/Search/TestSearcherManager.cs | 42 +++++-----
src/Lucene.Net.Tests/Search/TestSimilarity.cs | 24 +++---
.../Search/TestSloppyPhraseQuery.cs | 6 +-
src/Lucene.Net.Tests/Search/TestSort.cs | 36 ++++-----
src/Lucene.Net.Tests/Search/TestTermScorer.cs | 6 +-
.../Search/TestTimeLimitingCollector.cs | 6 +-
src/Lucene.Net.Tests/Store/TestRAMDirectory.cs | 6 +-
src/Lucene.Net.Tests/TestWorstCaseTestBehavior.cs | 12 +--
src/Lucene.Net.Tests/Util/Fst/TestFSTs.cs | 36 ++++-----
.../Util/Packed/TestEliasFanoDocIdSet.cs | 6 +-
src/Lucene.Net.Tests/Util/TestFilterIterator.cs | 42 +++++-----
src/Lucene.Net.Tests/Util/TestNumericUtils.cs | 12 +--
src/Lucene.Net.Tests/Util/TestRollingBuffer.cs | 6 +-
src/Lucene.Net.Tests/Util/TestWeakIdentityMap.cs | 8 +-
src/Lucene.Net/Analysis/Tokenizer.cs | 4 +-
.../Compressing/CompressingStoredFieldsReader.cs | 6 +-
.../Codecs/Compressing/CompressionMode.cs | 16 ++--
src/Lucene.Net/Codecs/Lucene3x/Lucene3xCodec.cs | 6 +-
.../Codecs/Lucene3x/Lucene3xNormsProducer.cs | 6 +-
.../Codecs/Lucene3x/Lucene3xTermVectorsReader.cs | 6 +-
src/Lucene.Net/Codecs/Lucene40/Lucene40Codec.cs | 6 +-
.../Codecs/Lucene40/Lucene40DocValuesReader.cs | 90 +++++++++++-----------
src/Lucene.Net/Codecs/Lucene41/Lucene41Codec.cs | 12 +--
src/Lucene.Net/Codecs/Lucene42/Lucene42Codec.cs | 16 ++--
.../Codecs/Lucene42/Lucene42DocValuesProducer.cs | 42 +++++-----
src/Lucene.Net/Codecs/Lucene45/Lucene45Codec.cs | 12 +--
.../Codecs/Lucene45/Lucene45DocValuesProducer.cs | 48 ++++++------
src/Lucene.Net/Codecs/Lucene46/Lucene46Codec.cs | 12 +--
.../Index/BinaryDocValuesFieldUpdates.cs | 6 +-
src/Lucene.Net/Index/CoalescedUpdates.cs | 20 ++---
src/Lucene.Net/Index/DocValues.cs | 36 ++++-----
.../Index/DocumentsWriterFlushControl.cs | 6 +-
src/Lucene.Net/Index/DocumentsWriterPerThread.cs | 6 +-
src/Lucene.Net/Index/FrozenBufferedUpdates.cs | 20 ++---
src/Lucene.Net/Index/MergePolicy.cs | 4 +-
src/Lucene.Net/Index/MergeState.cs | 12 +--
src/Lucene.Net/Index/MultiDocValues.cs | 18 ++---
.../Index/NumericDocValuesFieldUpdates.cs | 6 +-
src/Lucene.Net/Index/ParallelCompositeReader.cs | 12 +--
src/Lucene.Net/Index/SegmentInfos.cs | 6 +-
src/Lucene.Net/Index/StandardDirectoryReader.cs | 12 +--
src/Lucene.Net/Index/Terms.cs | 6 +-
src/Lucene.Net/Index/TermsEnum.cs | 8 +-
src/Lucene.Net/Index/TieredMergePolicy.cs | 6 +-
src/Lucene.Net/Search/BooleanScorer2.cs | 18 ++---
src/Lucene.Net/Search/CachingCollector.cs | 6 +-
src/Lucene.Net/Search/CachingWrapperFilter.cs | 4 +-
src/Lucene.Net/Search/ConstantScoreQuery.cs | 6 +-
src/Lucene.Net/Search/DocIdSetIterator.cs | 6 +-
src/Lucene.Net/Search/DocTermOrdsRangeFilter.cs | 6 +-
src/Lucene.Net/Search/DocTermOrdsRewriteMethod.cs | 6 +-
src/Lucene.Net/Search/FieldCacheDocIdSet.cs | 28 +++----
src/Lucene.Net/Search/FieldCacheImpl.cs | 90 +++++++++++-----------
src/Lucene.Net/Search/FieldCacheRewriteMethod.cs | 6 +-
src/Lucene.Net/Search/FilteredDocIdSet.cs | 12 +--
src/Lucene.Net/Search/FilteredQuery.cs | 6 +-
src/Lucene.Net/Search/MultiTermQuery.cs | 12 +--
src/Lucene.Net/Search/NumericRangeQuery.cs | 12 +--
src/Lucene.Net/Search/QueryRescorer.cs | 6 +-
src/Lucene.Net/Search/QueryWrapperFilter.cs | 6 +-
src/Lucene.Net/Search/RegexpQuery.cs | 4 +-
src/Lucene.Net/Search/ScoringRewrite.cs | 12 +--
src/Lucene.Net/Search/SortField.cs | 12 +--
src/Lucene.Net/Search/Spans/NearSpansOrdered.cs | 6 +-
.../Search/Spans/SpanMultiTermQueryWrapper.cs | 18 ++---
src/Lucene.Net/Search/Spans/SpanNotQuery.cs | 6 +-
src/Lucene.Net/Search/Spans/SpanOrQuery.cs | 6 +-
src/Lucene.Net/Search/TopTermsRewrite.cs | 6 +-
src/Lucene.Net/Store/CompoundFileDirectory.cs | 6 +-
src/Lucene.Net/Store/Directory.cs | 6 +-
src/Lucene.Net/Store/LockVerifyServer.cs | 6 +-
src/Lucene.Net/Store/MMapDirectory.cs | 6 +-
src/Lucene.Net/Store/NIOFSDirectory.cs | 6 +-
src/Lucene.Net/Store/SimpleFSDirectory.cs | 6 +-
src/Lucene.Net/Util/AttributeSource.cs | 12 +--
src/Lucene.Net/Util/BytesRefArray.cs | 12 +--
src/Lucene.Net/Util/BytesRefHash.cs | 6 +-
src/Lucene.Net/Util/Fst/NoOutputs.cs | 6 +-
src/Lucene.Net/Util/NumericUtils.cs | 12 +--
src/Lucene.Net/Util/OfflineSorter.cs | 6 +-
src/Lucene.Net/Util/Packed/EliasFanoDocIdSet.cs | 6 +-
src/Lucene.Net/Util/Packed/PackedInts.cs | 6 +-
src/Lucene.Net/Util/RamUsageEstimator.cs | 6 +-
src/Lucene.Net/Util/WAH8DocIdSet.cs | 6 +-
src/Lucene.Net/Util/WeakIdentityMap.cs | 6 +-
321 files changed, 1861 insertions(+), 1861 deletions(-)
diff --git a/CHANGES.txt b/CHANGES.txt
index 8383989..5c61e56 100644
--- a/CHANGES.txt
+++ b/CHANGES.txt
@@ -177,7 +177,7 @@ Bug
Van Den Berghe http://apache.markmail.org/message/hafnuhq2ydhfjmi2.
• Lucene.Net.Store.LockVerifyServer: Read/write 1 byte instead of 1 int (4 bytes).
Also, we don't need 2 streams in .NET for input/output (solution provided by Vincent Van Den Berghe).
-• Lucene.Net.TestFramework.Store.MockDirectoryWrapper.IndexInputSlicerAnonymousInnerClassHelper: Fixed Dispose() method.
+• Lucene.Net.TestFramework.Store.MockDirectoryWrapper.IndexInputSlicerAnonymousClass: Fixed Dispose() method.
• Lucene.Net.Index.IndexWriter: Fixed string formatting of numeric values in InfoStream message.
• Lucene.Net.Tests.Querys.CommonTermsQueryTest: Added missing TestRandomIndex() test
• Lucene.Net.Analysis.Common.Analysis.CharFilter.MappingCharFilterFactory: fixed escaping problem in parsing regex
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Miscellaneous/PrefixAndSuffixAwareTokenFilter.cs b/src/Lucene.Net.Analysis.Common/Analysis/Miscellaneous/PrefixAndSuffixAwareTokenFilter.cs
index 76125c6..65f3808 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Miscellaneous/PrefixAndSuffixAwareTokenFilter.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Miscellaneous/PrefixAndSuffixAwareTokenFilter.cs
@@ -31,15 +31,15 @@
public PrefixAndSuffixAwareTokenFilter(TokenStream prefix, TokenStream input, TokenStream suffix)
: base(suffix)
{
- prefix = new PrefixAwareTokenFilterAnonymousInnerClassHelper(this, prefix, input);
- this.suffix = new PrefixAwareTokenFilterAnonymousInnerClassHelper2(this, prefix, suffix);
+ prefix = new PrefixAwareTokenFilterAnonymousClass(this, prefix, input);
+ this.suffix = new PrefixAwareTokenFilterAnonymousClass2(this, prefix, suffix);
}
- private sealed class PrefixAwareTokenFilterAnonymousInnerClassHelper : PrefixAwareTokenFilter
+ private sealed class PrefixAwareTokenFilterAnonymousClass : PrefixAwareTokenFilter
{
private readonly PrefixAndSuffixAwareTokenFilter outerInstance;
- public PrefixAwareTokenFilterAnonymousInnerClassHelper(PrefixAndSuffixAwareTokenFilter outerInstance, TokenStream prefix, TokenStream input)
+ public PrefixAwareTokenFilterAnonymousClass(PrefixAndSuffixAwareTokenFilter outerInstance, TokenStream prefix, TokenStream input)
: base(prefix, input)
{
this.outerInstance = outerInstance;
@@ -51,11 +51,11 @@
}
}
- private sealed class PrefixAwareTokenFilterAnonymousInnerClassHelper2 : PrefixAwareTokenFilter
+ private sealed class PrefixAwareTokenFilterAnonymousClass2 : PrefixAwareTokenFilter
{
private readonly PrefixAndSuffixAwareTokenFilter outerInstance;
- public PrefixAwareTokenFilterAnonymousInnerClassHelper2(PrefixAndSuffixAwareTokenFilter outerInstance, TokenStream prefix, TokenStream suffix)
+ public PrefixAwareTokenFilterAnonymousClass2(PrefixAndSuffixAwareTokenFilter outerInstance, TokenStream prefix, TokenStream suffix)
: base(prefix, suffix)
{
this.outerInstance = outerInstance;
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/NGram/NGramTokenFilter.cs b/src/Lucene.Net.Analysis.Common/Analysis/NGram/NGramTokenFilter.cs
index 157fed6..0c5deef 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/NGram/NGramTokenFilter.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/NGram/NGramTokenFilter.cs
@@ -106,14 +106,14 @@ namespace Lucene.Net.Analysis.NGram
}
else
{
- posIncAtt = new PositionIncrementAttributeAnonymousInnerClassHelper();
- posLenAtt = new PositionLengthAttributeAnonymousInnerClassHelper();
+ posIncAtt = new PositionIncrementAttributeAnonymousClass();
+ posLenAtt = new PositionLengthAttributeAnonymousClass();
}
termAtt = AddAttribute<ICharTermAttribute>();
offsetAtt = AddAttribute<IOffsetAttribute>();
}
- private class PositionIncrementAttributeAnonymousInnerClassHelper : PositionIncrementAttribute
+ private class PositionIncrementAttributeAnonymousClass : PositionIncrementAttribute
{
public override int PositionIncrement
{
@@ -122,7 +122,7 @@ namespace Lucene.Net.Analysis.NGram
}
}
- private class PositionLengthAttributeAnonymousInnerClassHelper : PositionLengthAttribute
+ private class PositionLengthAttributeAnonymousClass : PositionLengthAttribute
{
public override int PositionLength
{
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Sinks/TeeSinkTokenFilter.cs b/src/Lucene.Net.Analysis.Common/Analysis/Sinks/TeeSinkTokenFilter.cs
index 09d202b..f66cd8c 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Sinks/TeeSinkTokenFilter.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Sinks/TeeSinkTokenFilter.cs
@@ -259,9 +259,9 @@ namespace Lucene.Net.Analysis.Sinks
}
}
- private static readonly SinkFilter ACCEPT_ALL_FILTER = new SinkFilterAnonymousInnerClassHelper();
+ private static readonly SinkFilter ACCEPT_ALL_FILTER = new SinkFilterAnonymousClass();
- private class SinkFilterAnonymousInnerClassHelper : SinkFilter
+ private class SinkFilterAnonymousClass : SinkFilter
{
public override bool Accept(AttributeSource source)
{
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Standard/ClassicAnalyzer.cs b/src/Lucene.Net.Analysis.Common/Analysis/Standard/ClassicAnalyzer.cs
index 6137851..b99a2f9 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Standard/ClassicAnalyzer.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Standard/ClassicAnalyzer.cs
@@ -104,16 +104,16 @@ namespace Lucene.Net.Analysis.Standard
TokenStream tok = new ClassicFilter(src);
tok = new LowerCaseFilter(m_matchVersion, tok);
tok = new StopFilter(m_matchVersion, tok, m_stopwords);
- return new TokenStreamComponentsAnonymousInnerClassHelper(this, src, tok);
+ return new TokenStreamComponentsAnonymousClass(this, src, tok);
}
- private class TokenStreamComponentsAnonymousInnerClassHelper : TokenStreamComponents
+ private class TokenStreamComponentsAnonymousClass : TokenStreamComponents
{
private readonly ClassicAnalyzer outerInstance;
private readonly ClassicTokenizer src;
- public TokenStreamComponentsAnonymousInnerClassHelper(ClassicAnalyzer outerInstance, ClassicTokenizer src, TokenStream tok)
+ public TokenStreamComponentsAnonymousClass(ClassicAnalyzer outerInstance, ClassicTokenizer src, TokenStream tok)
: base(src, tok)
{
this.outerInstance = outerInstance;
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Standard/StandardAnalyzer.cs b/src/Lucene.Net.Analysis.Common/Analysis/Standard/StandardAnalyzer.cs
index 8475d58..b5b9b9e 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Standard/StandardAnalyzer.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Standard/StandardAnalyzer.cs
@@ -105,16 +105,16 @@ namespace Lucene.Net.Analysis.Standard
TokenStream tok = new StandardFilter(m_matchVersion, src);
tok = new LowerCaseFilter(m_matchVersion, tok);
tok = new StopFilter(m_matchVersion, tok, m_stopwords);
- return new TokenStreamComponentsAnonymousInnerClassHelper(this, src, tok);
+ return new TokenStreamComponentsAnonymousClass(this, src, tok);
}
- private class TokenStreamComponentsAnonymousInnerClassHelper : TokenStreamComponents
+ private class TokenStreamComponentsAnonymousClass : TokenStreamComponents
{
private readonly StandardAnalyzer outerInstance;
private readonly StandardTokenizer src;
- public TokenStreamComponentsAnonymousInnerClassHelper(StandardAnalyzer outerInstance, StandardTokenizer src, TokenStream tok)
+ public TokenStreamComponentsAnonymousClass(StandardAnalyzer outerInstance, StandardTokenizer src, TokenStream tok)
: base(src, tok)
{
this.outerInstance = outerInstance;
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Standard/UAX29URLEmailAnalyzer.cs b/src/Lucene.Net.Analysis.Common/Analysis/Standard/UAX29URLEmailAnalyzer.cs
index 8d2f8a5..a42fe82 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Standard/UAX29URLEmailAnalyzer.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Standard/UAX29URLEmailAnalyzer.cs
@@ -95,16 +95,16 @@ namespace Lucene.Net.Analysis.Standard
TokenStream tok = new StandardFilter(m_matchVersion, src);
tok = new LowerCaseFilter(m_matchVersion, tok);
tok = new StopFilter(m_matchVersion, tok, m_stopwords);
- return new TokenStreamComponentsAnonymousInnerClassHelper(this, src, tok);
+ return new TokenStreamComponentsAnonymousClass(this, src, tok);
}
- private class TokenStreamComponentsAnonymousInnerClassHelper : TokenStreamComponents
+ private class TokenStreamComponentsAnonymousClass : TokenStreamComponents
{
private readonly UAX29URLEmailAnalyzer outerInstance;
private readonly UAX29URLEmailTokenizer src;
- public TokenStreamComponentsAnonymousInnerClassHelper(UAX29URLEmailAnalyzer outerInstance, UAX29URLEmailTokenizer src, TokenStream tok)
+ public TokenStreamComponentsAnonymousClass(UAX29URLEmailAnalyzer outerInstance, UAX29URLEmailTokenizer src, TokenStream tok)
: base(src, tok)
{
this.outerInstance = outerInstance;
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Util/CharArrayIterator.cs b/src/Lucene.Net.Analysis.Common/Analysis/Util/CharArrayIterator.cs
index 3a66d5b..7f014cd 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Util/CharArrayIterator.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Util/CharArrayIterator.cs
@@ -129,10 +129,10 @@ namespace Lucene.Net.Analysis.Util
/// </summary>
public static CharArrayIterator NewSentenceInstance()
{
- return new CharArrayIteratorAnonymousInnerClassHelper2();
+ return new CharArrayIteratorAnonymousClass2();
}
- private class CharArrayIteratorAnonymousInnerClassHelper2 : CharArrayIterator
+ private class CharArrayIteratorAnonymousClass2 : CharArrayIterator
{
// no bugs
protected override char JreBugWorkaround(char ch)
@@ -147,10 +147,10 @@ namespace Lucene.Net.Analysis.Util
/// </summary>
public static CharArrayIterator NewWordInstance()
{
- return new CharArrayIteratorAnonymousInnerClassHelper4();
+ return new CharArrayIteratorAnonymousClass4();
}
- private class CharArrayIteratorAnonymousInnerClassHelper4 : CharArrayIterator
+ private class CharArrayIteratorAnonymousClass4 : CharArrayIterator
{
// no bugs
protected override char JreBugWorkaround(char ch)
diff --git a/src/Lucene.Net.Analysis.ICU/Analysis/Icu/Segmentation/ICUTokenizerFactory.cs b/src/Lucene.Net.Analysis.ICU/Analysis/Icu/Segmentation/ICUTokenizerFactory.cs
index aa74389..5368b4d 100644
--- a/src/Lucene.Net.Analysis.ICU/Analysis/Icu/Segmentation/ICUTokenizerFactory.cs
+++ b/src/Lucene.Net.Analysis.ICU/Analysis/Icu/Segmentation/ICUTokenizerFactory.cs
@@ -112,14 +112,14 @@ namespace Lucene.Net.Analysis.Icu.Segmentation
}
else
{
- config = new DefaultICUTokenizerConfigAnonymousHelper(cjkAsWords, myanmarAsWords, tailored, loader);
+ config = new DefaultICUTokenizerConfigAnonymousClass(cjkAsWords, myanmarAsWords, tailored, loader);
}
}
- private class DefaultICUTokenizerConfigAnonymousHelper : DefaultICUTokenizerConfig
+ private class DefaultICUTokenizerConfigAnonymousClass : DefaultICUTokenizerConfig
{
private readonly BreakIterator[] breakers;
- public DefaultICUTokenizerConfigAnonymousHelper(bool cjkAsWords, bool myanmarAsWords, IDictionary<int, string> tailored, IResourceLoader loader)
+ public DefaultICUTokenizerConfigAnonymousClass(bool cjkAsWords, bool myanmarAsWords, IDictionary<int, string> tailored, IResourceLoader loader)
: base(cjkAsWords, myanmarAsWords)
{
breakers = new BreakIterator[1 + UChar.GetIntPropertyMaxValue(UProperty.Script)];
diff --git a/src/Lucene.Net.Analysis.Phonetic/Language/Bm/Rule.cs b/src/Lucene.Net.Analysis.Phonetic/Language/Bm/Rule.cs
index 23eb7ec..05c6633 100644
--- a/src/Lucene.Net.Analysis.Phonetic/Language/Bm/Rule.cs
+++ b/src/Lucene.Net.Analysis.Phonetic/Language/Bm/Rule.cs
@@ -398,12 +398,12 @@ namespace Lucene.Net.Analysis.Phonetic.Language.Bm
}
}
- private class RuleAnonymousHelper : Rule
+ private class RuleAnonymousClass : Rule
{
private readonly int myLine;
private readonly string loc;
- public RuleAnonymousHelper(string pat, string lCon, string rCon, IPhonemeExpr ph, int cLine, string location)
+ public RuleAnonymousClass(string pat, string lCon, string rCon, IPhonemeExpr ph, int cLine, string location)
: base(pat, lCon, rCon, ph)
{
this.myLine = cLine;
@@ -497,7 +497,7 @@ namespace Lucene.Net.Analysis.Phonetic.Language.Bm
string rCon = StripQuotes(parts[2]);
IPhonemeExpr ph = ParsePhonemeExpr(StripQuotes(parts[3]));
int cLine = currentLine;
- Rule r = new RuleAnonymousHelper(pat, lCon, rCon, ph, cLine, location);
+ Rule r = new RuleAnonymousClass(pat, lCon, rCon, ph, cLine, location);
string patternKey = r.pattern.Substring(0, 1 - 0);
if (!lines.TryGetValue(patternKey, out IList<Rule> rules) || rules == null)
diff --git a/src/Lucene.Net.Benchmark/ByTask/Feeds/DemoHTMLParser.cs b/src/Lucene.Net.Benchmark/ByTask/Feeds/DemoHTMLParser.cs
index 07f2a19..c210d59 100644
--- a/src/Lucene.Net.Benchmark/ByTask/Feeds/DemoHTMLParser.cs
+++ b/src/Lucene.Net.Benchmark/ByTask/Feeds/DemoHTMLParser.cs
@@ -61,7 +61,7 @@ namespace Lucene.Net.Benchmarks.ByTask.Feeds
parser.SetFeature(TagSoup.Parser.NAMESPACES_FEATURE, true);
StringBuilder title = new StringBuilder(), body = new StringBuilder();
- DefaultHandler handler = new DefaultHandlerAnonymousHelper(this, title, body);
+ DefaultHandler handler = new DefaultHandlerAnonymousClass(this, title, body);
parser.ContentHandler = handler;
parser.ErrorHandler = handler;
@@ -74,7 +74,7 @@ namespace Lucene.Net.Benchmarks.ByTask.Feeds
this.body = body.ToString();
}
- private class DefaultHandlerAnonymousHelper : DefaultHandler
+ private class DefaultHandlerAnonymousClass : DefaultHandler
{
private int inBODY = 0, inHEAD = 0, inTITLE = 0, suppressed = 0;
@@ -82,7 +82,7 @@ namespace Lucene.Net.Benchmarks.ByTask.Feeds
private readonly StringBuilder title;
private readonly StringBuilder body;
- public DefaultHandlerAnonymousHelper(Parser outerInstance, StringBuilder title, StringBuilder body)
+ public DefaultHandlerAnonymousClass(Parser outerInstance, StringBuilder title, StringBuilder body)
{
this.outerInstance = outerInstance;
this.title = title;
diff --git a/src/Lucene.Net.Benchmark/ByTask/Feeds/SpatialDocMaker.cs b/src/Lucene.Net.Benchmark/ByTask/Feeds/SpatialDocMaker.cs
index 8953a47..d7ae442 100644
--- a/src/Lucene.Net.Benchmark/ByTask/Feeds/SpatialDocMaker.cs
+++ b/src/Lucene.Net.Benchmark/ByTask/Feeds/SpatialDocMaker.cs
@@ -68,7 +68,7 @@ namespace Lucene.Net.Benchmarks.ByTask.Feeds
protected virtual SpatialStrategy MakeSpatialStrategy(Config config)
{
//A Map view of Config that prefixes keys with "spatial."
- var configMap = new DictionaryAnonymousHelper(config);
+ var configMap = new DictionaryAnonymousClass(config);
SpatialContext ctx = SpatialContextFactory.MakeSpatialContext(configMap /*, null*/); // LUCENENET TODO: What is this extra param?
@@ -77,10 +77,10 @@ namespace Lucene.Net.Benchmarks.ByTask.Feeds
return MakeSpatialStrategy(config, configMap, ctx);
}
- private class DictionaryAnonymousHelper : Dictionary<string, string>
+ private class DictionaryAnonymousClass : Dictionary<string, string>
{
private readonly Config config;
- public DictionaryAnonymousHelper(Config config)
+ public DictionaryAnonymousClass(Config config)
{
this.config = config;
}
@@ -96,7 +96,7 @@ namespace Lucene.Net.Benchmarks.ByTask.Feeds
//A factory for the prefix tree grid
SpatialPrefixTree grid = SpatialPrefixTreeFactory.MakeSPT(configMap, /*null,*/ ctx); // LUCENENET TODO: What is this extra param?
- RecursivePrefixTreeStrategy strategy = new RecursivePrefixTreeStrategyAnonymousHelper(grid, SPATIAL_FIELD, config);
+ RecursivePrefixTreeStrategy strategy = new RecursivePrefixTreeStrategyAnonymousClass(grid, SPATIAL_FIELD, config);
int prefixGridScanLevel = config.Get("query.spatial.prefixGridScanLevel", -4);
if (prefixGridScanLevel < 0)
@@ -108,9 +108,9 @@ namespace Lucene.Net.Benchmarks.ByTask.Feeds
return strategy;
}
- private class RecursivePrefixTreeStrategyAnonymousHelper : RecursivePrefixTreeStrategy
+ private class RecursivePrefixTreeStrategyAnonymousClass : RecursivePrefixTreeStrategy
{
- public RecursivePrefixTreeStrategyAnonymousHelper(SpatialPrefixTree grid, string fieldName, Config config)
+ public RecursivePrefixTreeStrategyAnonymousClass(SpatialPrefixTree grid, string fieldName, Config config)
: base(grid, fieldName)
{
this.m_pointsOnly = config.Get("spatial.docPointsOnly", false);
@@ -142,17 +142,17 @@ namespace Lucene.Net.Benchmarks.ByTask.Feeds
double plusMinus = config.Get(configKeyPrefix + "radiusDegreesRandPlusMinus", 0.0);
bool bbox = config.Get(configKeyPrefix + "bbox", false);
- return new ShapeConverterAnonymousHelper(spatialStrategy, radiusDegrees, plusMinus, bbox);
+ return new ShapeConverterAnonymousClass(spatialStrategy, radiusDegrees, plusMinus, bbox);
}
- private class ShapeConverterAnonymousHelper : IShapeConverter
+ private class ShapeConverterAnonymousClass : IShapeConverter
{
private readonly SpatialStrategy spatialStrategy;
private readonly double radiusDegrees;
private readonly double plusMinus;
private readonly bool bbox;
- public ShapeConverterAnonymousHelper(SpatialStrategy spatialStrategy, double radiusDegrees, double plusMinus, bool bbox)
+ public ShapeConverterAnonymousClass(SpatialStrategy spatialStrategy, double radiusDegrees, double plusMinus, bool bbox)
{
this.spatialStrategy = spatialStrategy;
this.radiusDegrees = radiusDegrees;
diff --git a/src/Lucene.Net.Benchmark/ByTask/Tasks/SearchTravRetHighlightTask.cs b/src/Lucene.Net.Benchmark/ByTask/Tasks/SearchTravRetHighlightTask.cs
index 21b1619..19a5af5 100644
--- a/src/Lucene.Net.Benchmark/ByTask/Tasks/SearchTravRetHighlightTask.cs
+++ b/src/Lucene.Net.Benchmark/ByTask/Tasks/SearchTravRetHighlightTask.cs
@@ -94,15 +94,15 @@ namespace Lucene.Net.Benchmarks.ByTask.Tasks
{
m_highlighter = new Highlighter(new SimpleHTMLFormatter(), new QueryScorer(q));
m_highlighter.MaxDocCharsToAnalyze = m_maxDocCharsToAnalyze;
- return new BenchmarkHighlighterAnonymousHelper(this, m_highlighter);
+ return new BenchmarkHighlighterAnonymousClass(this, m_highlighter);
}
- private class BenchmarkHighlighterAnonymousHelper : BenchmarkHighlighter
+ private class BenchmarkHighlighterAnonymousClass : BenchmarkHighlighter
{
private readonly SearchTravRetHighlightTask outerInstance;
private readonly Highlighter highlighter;
- public BenchmarkHighlighterAnonymousHelper(SearchTravRetHighlightTask outerInstance, Highlighter highlighter)
+ public BenchmarkHighlighterAnonymousClass(SearchTravRetHighlightTask outerInstance, Highlighter highlighter)
{
this.outerInstance = outerInstance;
this.highlighter = highlighter;
diff --git a/src/Lucene.Net.Benchmark/ByTask/Tasks/SearchTravRetVectorHighlightTask.cs b/src/Lucene.Net.Benchmark/ByTask/Tasks/SearchTravRetVectorHighlightTask.cs
index 365c152..b898bc0 100644
--- a/src/Lucene.Net.Benchmark/ByTask/Tasks/SearchTravRetVectorHighlightTask.cs
+++ b/src/Lucene.Net.Benchmark/ByTask/Tasks/SearchTravRetVectorHighlightTask.cs
@@ -98,15 +98,15 @@ namespace Lucene.Net.Benchmarks.ByTask.Tasks
{
m_highlighter = new FastVectorHighlighter(false, false);
Query myq = q;
- return new BenchmarkHighlighterAnonymousHelper(this, m_highlighter, myq);
+ return new BenchmarkHighlighterAnonymousClass(this, m_highlighter, myq);
}
- private class BenchmarkHighlighterAnonymousHelper : BenchmarkHighlighter
+ private class BenchmarkHighlighterAnonymousClass : BenchmarkHighlighter
{
private readonly SearchTravRetVectorHighlightTask outerInstance;
private readonly FastVectorHighlighter highlighter;
private readonly Query myq;
- public BenchmarkHighlighterAnonymousHelper(SearchTravRetVectorHighlightTask outerInstance, FastVectorHighlighter highlighter, Query myq)
+ public BenchmarkHighlighterAnonymousClass(SearchTravRetVectorHighlightTask outerInstance, FastVectorHighlighter highlighter, Query myq)
{
this.outerInstance = outerInstance;
this.highlighter = highlighter;
diff --git a/src/Lucene.Net.Benchmark/ByTask/Utils/AnalyzerFactory.cs b/src/Lucene.Net.Benchmark/ByTask/Utils/AnalyzerFactory.cs
index 257c662..90a08fe 100644
--- a/src/Lucene.Net.Benchmark/ByTask/Utils/AnalyzerFactory.cs
+++ b/src/Lucene.Net.Benchmark/ByTask/Utils/AnalyzerFactory.cs
@@ -51,14 +51,14 @@ namespace Lucene.Net.Benchmarks.ByTask.Utils
public Analyzer Create()
{
- return new AnalyzerAnonymousHelper(this);
+ return new AnalyzerAnonymousClass(this);
}
- private sealed class AnalyzerAnonymousHelper : Analyzer
+ private sealed class AnalyzerAnonymousClass : Analyzer
{
private readonly AnalyzerFactory outerInstance;
- public AnalyzerAnonymousHelper(AnalyzerFactory outerInstance)
+ public AnalyzerAnonymousClass(AnalyzerFactory outerInstance)
{
this.outerInstance = outerInstance;
}
diff --git a/src/Lucene.Net.Benchmark/Quality/Utils/DocNameExtractor.cs b/src/Lucene.Net.Benchmark/Quality/Utils/DocNameExtractor.cs
index ee9bdec..395d2bf 100644
--- a/src/Lucene.Net.Benchmark/Quality/Utils/DocNameExtractor.cs
+++ b/src/Lucene.Net.Benchmark/Quality/Utils/DocNameExtractor.cs
@@ -49,17 +49,17 @@ namespace Lucene.Net.Benchmarks.Quality.Utils
public virtual string DocName(IndexSearcher searcher, int docid)
{
IList<string> name = new List<string>();
- searcher.IndexReader.Document(docid, new StoredFieldVisitorAnonymousHelper(this, name));
+ searcher.IndexReader.Document(docid, new StoredFieldVisitorAnonymousClass(this, name));
return name.Count > 0 ? name[0] : null;
}
- private class StoredFieldVisitorAnonymousHelper : StoredFieldVisitor
+ private class StoredFieldVisitorAnonymousClass : StoredFieldVisitor
{
private readonly DocNameExtractor outerInstance;
private readonly IList<string> name;
- public StoredFieldVisitorAnonymousHelper(DocNameExtractor outerInstance, IList<string> name)
+ public StoredFieldVisitorAnonymousClass(DocNameExtractor outerInstance, IList<string> name)
{
this.outerInstance = outerInstance;
this.name = name;
diff --git a/src/Lucene.Net.Codecs/DiskDV/DiskDocValuesFormat.cs b/src/Lucene.Net.Codecs/DiskDV/DiskDocValuesFormat.cs
index a5a5949..57a37b5 100644
--- a/src/Lucene.Net.Codecs/DiskDV/DiskDocValuesFormat.cs
+++ b/src/Lucene.Net.Codecs/DiskDV/DiskDocValuesFormat.cs
@@ -38,12 +38,12 @@ namespace Lucene.Net.Codecs.DiskDV
public override DocValuesConsumer FieldsConsumer(SegmentWriteState state)
{
- return new Lucene45DocValuesConsumerAnonymousHelper(state);
+ return new Lucene45DocValuesConsumerAnonymousClass(state);
}
- private class Lucene45DocValuesConsumerAnonymousHelper : Lucene45DocValuesConsumer
+ private class Lucene45DocValuesConsumerAnonymousClass : Lucene45DocValuesConsumer
{
- public Lucene45DocValuesConsumerAnonymousHelper(SegmentWriteState state)
+ public Lucene45DocValuesConsumerAnonymousClass(SegmentWriteState state)
: base(state, DATA_CODEC, DATA_EXTENSION, META_CODEC, META_EXTENSION)
{
}
diff --git a/src/Lucene.Net.Codecs/Memory/DirectDocValuesConsumer.cs b/src/Lucene.Net.Codecs/Memory/DirectDocValuesConsumer.cs
index d7b6787..ee63af2 100644
--- a/src/Lucene.Net.Codecs/Memory/DirectDocValuesConsumer.cs
+++ b/src/Lucene.Net.Codecs/Memory/DirectDocValuesConsumer.cs
@@ -295,7 +295,7 @@ namespace Lucene.Net.Codecs.Memory
// First write docToOrdCounts, except we "aggregate" the
// counts so they turn into addresses, and add a final
// value = the total aggregate:
- AddNumericFieldValues(field, new EnumerableAnonymousInnerClassHelper(docToOrdCount));
+ AddNumericFieldValues(field, new EnumerableAnonymousClass(docToOrdCount));
// Write ordinals for all docs, appended into one big
// numerics:
@@ -305,11 +305,11 @@ namespace Lucene.Net.Codecs.Memory
AddBinaryFieldValues(field, values);
}
- private class EnumerableAnonymousInnerClassHelper : IEnumerable<long?>
+ private class EnumerableAnonymousClass : IEnumerable<long?>
{
private readonly IEnumerable<long?> _docToOrdCount;
- public EnumerableAnonymousInnerClassHelper(IEnumerable<long?> docToOrdCount)
+ public EnumerableAnonymousClass(IEnumerable<long?> docToOrdCount)
{
_docToOrdCount = docToOrdCount;
}
diff --git a/src/Lucene.Net.Codecs/Memory/DirectDocValuesProducer.cs b/src/Lucene.Net.Codecs/Memory/DirectDocValuesProducer.cs
index 9028f83..41eaef9 100644
--- a/src/Lucene.Net.Codecs/Memory/DirectDocValuesProducer.cs
+++ b/src/Lucene.Net.Codecs/Memory/DirectDocValuesProducer.cs
@@ -234,7 +234,7 @@ namespace Lucene.Net.Codecs.Memory
data.ReadBytes(values, 0, entry.count);
ramBytesUsed.AddAndGet(RamUsageEstimator.SizeOf(values));
// LUCENENET: IMPORTANT - some bytes are negative here, so we need to pass as sbyte
- return new NumericDocValuesAnonymousInnerClassHelper((sbyte[])(Array)values);
+ return new NumericDocValuesAnonymousClass((sbyte[])(Array)values);
}
case 2:
@@ -245,7 +245,7 @@ namespace Lucene.Net.Codecs.Memory
values[i] = data.ReadInt16();
}
ramBytesUsed.AddAndGet(RamUsageEstimator.SizeOf(values));
- return new NumericDocValuesAnonymousInnerClassHelper2(values);
+ return new NumericDocValuesAnonymousClass2(values);
}
case 4:
@@ -256,7 +256,7 @@ namespace Lucene.Net.Codecs.Memory
values[i] = data.ReadInt32();
}
ramBytesUsed.AddAndGet(RamUsageEstimator.SizeOf(values));
- return new NumericDocValuesAnonymousInnerClassHelper3(values);
+ return new NumericDocValuesAnonymousClass3(values);
}
case 8:
@@ -267,7 +267,7 @@ namespace Lucene.Net.Codecs.Memory
values[i] = data.ReadInt64();
}
ramBytesUsed.AddAndGet(RamUsageEstimator.SizeOf(values));
- return new NumericDocValuesAnonymousInnerClassHelper4(values);
+ return new NumericDocValuesAnonymousClass4(values);
}
default:
@@ -275,11 +275,11 @@ namespace Lucene.Net.Codecs.Memory
}
}
- private class NumericDocValuesAnonymousInnerClassHelper : NumericDocValues
+ private class NumericDocValuesAnonymousClass : NumericDocValues
{
private readonly sbyte[] values;
- public NumericDocValuesAnonymousInnerClassHelper(sbyte[] values)
+ public NumericDocValuesAnonymousClass(sbyte[] values)
{
this.values = values;
}
@@ -290,11 +290,11 @@ namespace Lucene.Net.Codecs.Memory
}
}
- private class NumericDocValuesAnonymousInnerClassHelper2 : NumericDocValues
+ private class NumericDocValuesAnonymousClass2 : NumericDocValues
{
private readonly short[] values;
- public NumericDocValuesAnonymousInnerClassHelper2(short[] values)
+ public NumericDocValuesAnonymousClass2(short[] values)
{
this.values = values;
}
@@ -305,11 +305,11 @@ namespace Lucene.Net.Codecs.Memory
}
}
- private class NumericDocValuesAnonymousInnerClassHelper3 : NumericDocValues
+ private class NumericDocValuesAnonymousClass3 : NumericDocValues
{
private readonly int[] values;
- public NumericDocValuesAnonymousInnerClassHelper3(int[] values)
+ public NumericDocValuesAnonymousClass3(int[] values)
{
this.values = values;
}
@@ -320,11 +320,11 @@ namespace Lucene.Net.Codecs.Memory
}
}
- private class NumericDocValuesAnonymousInnerClassHelper4 : NumericDocValues
+ private class NumericDocValuesAnonymousClass4 : NumericDocValues
{
private readonly long[] values;
- public NumericDocValuesAnonymousInnerClassHelper4(long[] values)
+ public NumericDocValuesAnonymousClass4(long[] values)
{
this.values = values;
}
@@ -365,15 +365,15 @@ namespace Lucene.Net.Codecs.Memory
ramBytesUsed.AddAndGet(RamUsageEstimator.SizeOf(bytes) + RamUsageEstimator.SizeOf(address));
- return new BinaryDocValuesAnonymousInnerClassHelper(bytes, address);
+ return new BinaryDocValuesAnonymousClass(bytes, address);
}
- private class BinaryDocValuesAnonymousInnerClassHelper : BinaryDocValues
+ private class BinaryDocValuesAnonymousClass : BinaryDocValues
{
private readonly byte[] bytes;
private readonly int[] address;
- public BinaryDocValuesAnonymousInnerClassHelper(byte[] bytes, int[] address)
+ public BinaryDocValuesAnonymousClass(byte[] bytes, int[] address)
{
this.bytes = bytes;
this.address = address;
@@ -407,16 +407,16 @@ namespace Lucene.Net.Codecs.Memory
NumericDocValues docToOrd = LoadNumeric(entry.docToOrd);
BinaryDocValues values = LoadBinary(entry.values);
- return new SortedDocValuesAnonymousInnerClassHelper(entry, docToOrd, values);
+ return new SortedDocValuesAnonymousClass(entry, docToOrd, values);
}
- private class SortedDocValuesAnonymousInnerClassHelper : SortedDocValues
+ private class SortedDocValuesAnonymousClass : SortedDocValues
{
private readonly SortedEntry entry;
private readonly NumericDocValues docToOrd;
private readonly BinaryDocValues values;
- public SortedDocValuesAnonymousInnerClassHelper(SortedEntry entry, NumericDocValues docToOrd, BinaryDocValues values)
+ public SortedDocValuesAnonymousClass(SortedEntry entry, NumericDocValues docToOrd, BinaryDocValues values)
{
this.entry = entry;
this.docToOrd = docToOrd;
@@ -458,18 +458,18 @@ namespace Lucene.Net.Codecs.Memory
var values = instance.values;
// Must make a new instance since the iterator has state:
- return new RandomAccessOrdsAnonymousInnerClassHelper(entry, docToOrdAddress, ords, values);
+ return new RandomAccessOrdsAnonymousClass(entry, docToOrdAddress, ords, values);
}
}
- private class RandomAccessOrdsAnonymousInnerClassHelper : RandomAccessOrds
+ private class RandomAccessOrdsAnonymousClass : RandomAccessOrds
{
private readonly SortedSetEntry entry;
private readonly NumericDocValues docToOrdAddress;
private readonly NumericDocValues ords;
private readonly BinaryDocValues values;
- public RandomAccessOrdsAnonymousInnerClassHelper(SortedSetEntry entry, NumericDocValues docToOrdAddress, NumericDocValues ords, BinaryDocValues values)
+ public RandomAccessOrdsAnonymousClass(SortedSetEntry entry, NumericDocValues docToOrdAddress, NumericDocValues ords, BinaryDocValues values)
{
this.entry = entry;
this.docToOrdAddress = docToOrdAddress;
diff --git a/src/Lucene.Net.Codecs/Memory/MemoryDocValuesConsumer.cs b/src/Lucene.Net.Codecs/Memory/MemoryDocValuesConsumer.cs
index 5776bcf..bd67a5b 100644
--- a/src/Lucene.Net.Codecs/Memory/MemoryDocValuesConsumer.cs
+++ b/src/Lucene.Net.Codecs/Memory/MemoryDocValuesConsumer.cs
@@ -403,18 +403,18 @@ namespace Lucene.Net.Codecs.Memory
IEnumerable<long?> docToOrdCount, IEnumerable<long?> ords)
{
// write the ordinals as a binary field
- AddBinaryField(field, new IterableAnonymousInnerClassHelper(docToOrdCount, ords));
+ AddBinaryField(field, new IterableAnonymousClass(docToOrdCount, ords));
// write the values as FST
WriteFST(field, values);
}
- private class IterableAnonymousInnerClassHelper : IEnumerable<BytesRef>
+ private class IterableAnonymousClass : IEnumerable<BytesRef>
{
private readonly IEnumerable<long?> _docToOrdCount;
private readonly IEnumerable<long?> _ords;
- public IterableAnonymousInnerClassHelper(IEnumerable<long?> docToOrdCount, IEnumerable<long?> ords)
+ public IterableAnonymousClass(IEnumerable<long?> docToOrdCount, IEnumerable<long?> ords)
{
_docToOrdCount = docToOrdCount;
_ords = ords;
diff --git a/src/Lucene.Net.Codecs/Memory/MemoryDocValuesProducer.cs b/src/Lucene.Net.Codecs/Memory/MemoryDocValuesProducer.cs
index a1c2618..82aaaf5 100644
--- a/src/Lucene.Net.Codecs/Memory/MemoryDocValuesProducer.cs
+++ b/src/Lucene.Net.Codecs/Memory/MemoryDocValuesProducer.cs
@@ -251,7 +251,7 @@ namespace Lucene.Net.Codecs.Memory
var ordsReader = PackedInt32s.GetReaderNoHeader(data, PackedInt32s.Format.ById(formatID),
entry.packedIntsVersion, maxDoc, bitsPerValue);
ramBytesUsed.AddAndGet(RamUsageEstimator.SizeOf(decode) + ordsReader.RamBytesUsed());
- return new NumericDocValuesAnonymousInnerClassHelper(decode, ordsReader);
+ return new NumericDocValuesAnonymousClass(decode, ordsReader);
case DELTA_COMPRESSED:
int blockSize = data.ReadVInt32();
var reader = new BlockPackedReader(data, entry.packedIntsVersion, blockSize, maxDoc,
@@ -263,7 +263,7 @@ namespace Lucene.Net.Codecs.Memory
data.ReadBytes(bytes, 0, bytes.Length);
ramBytesUsed.AddAndGet(RamUsageEstimator.SizeOf(bytes));
// LUCENENET: IMPORTANT - some bytes are negative here, so we need to pass as sbyte
- return new NumericDocValuesAnonymousInnerClassHelper2((sbyte[])(Array)bytes);
+ return new NumericDocValuesAnonymousClass2((sbyte[])(Array)bytes);
case GCD_COMPRESSED:
long min = data.ReadInt64();
long mult = data.ReadInt64();
@@ -271,18 +271,18 @@ namespace Lucene.Net.Codecs.Memory
var quotientReader = new BlockPackedReader(data, entry.packedIntsVersion,
quotientBlockSize, maxDoc, false);
ramBytesUsed.AddAndGet(quotientReader.RamBytesUsed());
- return new NumericDocValuesAnonymousInnerClassHelper3(min, mult, quotientReader);
+ return new NumericDocValuesAnonymousClass3(min, mult, quotientReader);
default:
throw new InvalidOperationException();
}
}
- private class NumericDocValuesAnonymousInnerClassHelper : NumericDocValues
+ private class NumericDocValuesAnonymousClass : NumericDocValues
{
private readonly long[] decode;
private readonly PackedInt32s.Reader ordsReader;
- public NumericDocValuesAnonymousInnerClassHelper(long[] decode, PackedInt32s.Reader ordsReader)
+ public NumericDocValuesAnonymousClass(long[] decode, PackedInt32s.Reader ordsReader)
{
this.decode = decode;
this.ordsReader = ordsReader;
@@ -294,11 +294,11 @@ namespace Lucene.Net.Codecs.Memory
}
}
- private class NumericDocValuesAnonymousInnerClassHelper2 : NumericDocValues
+ private class NumericDocValuesAnonymousClass2 : NumericDocValues
{
private readonly sbyte[] bytes;
- public NumericDocValuesAnonymousInnerClassHelper2(sbyte[] bytes)
+ public NumericDocValuesAnonymousClass2(sbyte[] bytes)
{
this.bytes = bytes;
}
@@ -309,13 +309,13 @@ namespace Lucene.Net.Codecs.Memory
}
}
- private class NumericDocValuesAnonymousInnerClassHelper3 : NumericDocValues
+ private class NumericDocValuesAnonymousClass3 : NumericDocValues
{
private readonly long min;
private readonly long mult;
private readonly BlockPackedReader quotientReader;
- public NumericDocValuesAnonymousInnerClassHelper3(long min, long mult,
+ public NumericDocValuesAnonymousClass3(long min, long mult,
BlockPackedReader quotientReader)
{
this.min = min;
@@ -353,7 +353,7 @@ namespace Lucene.Net.Codecs.Memory
{
int fixedLength = entry.minLength;
ramBytesUsed.AddAndGet(bytes.RamBytesUsed());
- return new BinaryDocValuesAnonymousInnerClassHelper(bytesReader, fixedLength);
+ return new BinaryDocValuesAnonymousClass(bytesReader, fixedLength);
}
else
{
@@ -361,16 +361,16 @@ namespace Lucene.Net.Codecs.Memory
var addresses = new MonotonicBlockPackedReader(data, entry.packedIntsVersion,
entry.blockSize, maxDoc, false);
ramBytesUsed.AddAndGet(bytes.RamBytesUsed() + addresses.RamBytesUsed());
- return new BinaryDocValuesAnonymousInnerClassHelper2(bytesReader, addresses);
+ return new BinaryDocValuesAnonymousClass2(bytesReader, addresses);
}
}
- private class BinaryDocValuesAnonymousInnerClassHelper : BinaryDocValues
+ private class BinaryDocValuesAnonymousClass : BinaryDocValues
{
private readonly PagedBytes.Reader bytesReader;
private readonly int fixedLength;
- public BinaryDocValuesAnonymousInnerClassHelper(PagedBytes.Reader bytesReader, int fixedLength)
+ public BinaryDocValuesAnonymousClass(PagedBytes.Reader bytesReader, int fixedLength)
{
this.bytesReader = bytesReader;
this.fixedLength = fixedLength;
@@ -382,12 +382,12 @@ namespace Lucene.Net.Codecs.Memory
}
}
- private class BinaryDocValuesAnonymousInnerClassHelper2 : BinaryDocValues
+ private class BinaryDocValuesAnonymousClass2 : BinaryDocValues
{
private readonly PagedBytes.Reader bytesReader;
private readonly MonotonicBlockPackedReader addresses;
- public BinaryDocValuesAnonymousInnerClassHelper2(PagedBytes.Reader bytesReader, MonotonicBlockPackedReader addresses)
+ public BinaryDocValuesAnonymousClass2(PagedBytes.Reader bytesReader, MonotonicBlockPackedReader addresses)
{
this.bytesReader = bytesReader;
this.addresses = addresses;
@@ -429,11 +429,11 @@ namespace Lucene.Net.Codecs.Memory
var scratchInts = new Int32sRef();
var fstEnum = new BytesRefFSTEnum<long?>(fst);
- return new SortedDocValuesAnonymousInnerClassHelper(entry, docToOrd, fst, @in, firstArc, scratchArc,
+ return new SortedDocValuesAnonymousClass(entry, docToOrd, fst, @in, firstArc, scratchArc,
scratchInts, fstEnum);
}
- private class SortedDocValuesAnonymousInnerClassHelper : SortedDocValues
+ private class SortedDocValuesAnonymousClass : SortedDocValues
{
private readonly MemoryDocValuesProducer.FSTEntry entry;
private readonly NumericDocValues docToOrd;
@@ -444,7 +444,7 @@ namespace Lucene.Net.Codecs.Memory
private readonly Int32sRef scratchInts;
private readonly BytesRefFSTEnum<long?> fstEnum;
- public SortedDocValuesAnonymousInnerClassHelper(FSTEntry fstEntry,
+ public SortedDocValuesAnonymousClass(FSTEntry fstEntry,
NumericDocValues numericDocValues, FST<long?> fst1, FST.BytesReader @in, FST.Arc<long?> arc, FST.Arc<long?> scratchArc1,
Int32sRef intsRef, BytesRefFSTEnum<long?> bytesRefFstEnum)
{
@@ -542,11 +542,11 @@ namespace Lucene.Net.Codecs.Memory
var fstEnum = new BytesRefFSTEnum<long?>(fst);
var @ref = new BytesRef();
var input = new ByteArrayDataInput();
- return new SortedSetDocValuesAnonymousInnerClassHelper(entry, docToOrds, fst, @in, firstArc,
+ return new SortedSetDocValuesAnonymousClass(entry, docToOrds, fst, @in, firstArc,
scratchArc, scratchInts, fstEnum, @ref, input);
}
- private class SortedSetDocValuesAnonymousInnerClassHelper : SortedSetDocValues
+ private class SortedSetDocValuesAnonymousClass : SortedSetDocValues
{
private readonly MemoryDocValuesProducer.FSTEntry entry;
private readonly BinaryDocValues docToOrds;
@@ -561,7 +561,7 @@ namespace Lucene.Net.Codecs.Memory
private long currentOrd;
- public SortedSetDocValuesAnonymousInnerClassHelper(FSTEntry fstEntry, BinaryDocValues binaryDocValues, FST<long?> fst1,
+ public SortedSetDocValuesAnonymousClass(FSTEntry fstEntry, BinaryDocValues binaryDocValues, FST<long?> fst1,
FST.BytesReader @in, FST.Arc<long?> arc, FST.Arc<long?> scratchArc1, Int32sRef intsRef, BytesRefFSTEnum<long?> bytesRefFstEnum,
BytesRef @ref, ByteArrayDataInput byteArrayDataInput)
{
diff --git a/src/Lucene.Net.Codecs/Memory/MemoryPostingsFormat.cs b/src/Lucene.Net.Codecs/Memory/MemoryPostingsFormat.cs
index d5758fb..9d51b0e 100644
--- a/src/Lucene.Net.Codecs/Memory/MemoryPostingsFormat.cs
+++ b/src/Lucene.Net.Codecs/Memory/MemoryPostingsFormat.cs
@@ -335,16 +335,16 @@ namespace Lucene.Net.Codecs.Memory
}
}
- return new FieldsConsumerAnonymousInnerClassHelper(this, @out);
+ return new FieldsConsumerAnonymousClass(this, @out);
}
- private class FieldsConsumerAnonymousInnerClassHelper : FieldsConsumer
+ private class FieldsConsumerAnonymousClass : FieldsConsumer
{
private readonly MemoryPostingsFormat outerInstance;
private readonly IndexOutput @out;
- public FieldsConsumerAnonymousInnerClassHelper(MemoryPostingsFormat outerInstance, IndexOutput @out)
+ public FieldsConsumerAnonymousClass(MemoryPostingsFormat outerInstance, IndexOutput @out)
{
this.outerInstance = outerInstance;
this.@out = @out;
@@ -976,14 +976,14 @@ namespace Lucene.Net.Codecs.Memory
@in.Dispose();
}
- return new FieldsProducerAnonymousInnerClassHelper(fields);
+ return new FieldsProducerAnonymousClass(fields);
}
- private class FieldsProducerAnonymousInnerClassHelper : FieldsProducer
+ private class FieldsProducerAnonymousClass : FieldsProducer
{
private readonly IDictionary<string, TermsReader> _fields;
- public FieldsProducerAnonymousInnerClassHelper(IDictionary<string, TermsReader> fields)
+ public FieldsProducerAnonymousClass(IDictionary<string, TermsReader> fields)
{
_fields = fields;
}
diff --git a/src/Lucene.Net.Codecs/SimpleText/SimpleTextDocValuesReader.cs b/src/Lucene.Net.Codecs/SimpleText/SimpleTextDocValuesReader.cs
index f9c1a64..9e1515d 100644
--- a/src/Lucene.Net.Codecs/SimpleText/SimpleTextDocValuesReader.cs
+++ b/src/Lucene.Net.Codecs/SimpleText/SimpleTextDocValuesReader.cs
@@ -156,10 +156,10 @@ namespace Lucene.Net.Codecs.SimpleText
var @in = (IndexInput)data.Clone();
var scratch = new BytesRef();
- return new NumericDocValuesAnonymousInnerClassHelper(this, field, @in, scratch);
+ return new NumericDocValuesAnonymousClass(this, field, @in, scratch);
}
- private class NumericDocValuesAnonymousInnerClassHelper : NumericDocValues
+ private class NumericDocValuesAnonymousClass : NumericDocValues
{
private readonly SimpleTextDocValuesReader _outerInstance;
@@ -167,7 +167,7 @@ namespace Lucene.Net.Codecs.SimpleText
private readonly IndexInput _input;
private readonly BytesRef _scratch;
- public NumericDocValuesAnonymousInnerClassHelper(SimpleTextDocValuesReader outerInstance,
+ public NumericDocValuesAnonymousClass(SimpleTextDocValuesReader outerInstance,
OneField field, IndexInput input, BytesRef scratch)
{
_outerInstance = outerInstance;
@@ -206,10 +206,10 @@ namespace Lucene.Net.Codecs.SimpleText
var field = fields[fieldInfo.Name];
var input = (IndexInput)data.Clone();
var scratch = new BytesRef();
- return new BitsAnonymousInnerClassHelper(this, field, input, scratch);
+ return new BitsAnonymousClass(this, field, input, scratch);
}
- private class BitsAnonymousInnerClassHelper : IBits
+ private class BitsAnonymousClass : IBits
{
private readonly SimpleTextDocValuesReader _outerInstance;
@@ -217,7 +217,7 @@ namespace Lucene.Net.Codecs.SimpleText
private readonly IndexInput _input;
private readonly BytesRef _scratch;
- public BitsAnonymousInnerClassHelper(SimpleTextDocValuesReader outerInstance,
+ public BitsAnonymousClass(SimpleTextDocValuesReader outerInstance,
OneField field, IndexInput @in, BytesRef scratch)
{
_outerInstance = outerInstance;
@@ -251,10 +251,10 @@ namespace Lucene.Net.Codecs.SimpleText
var input = (IndexInput)data.Clone();
var scratch = new BytesRef();
- return new BinaryDocValuesAnonymousInnerClassHelper(this, field, input, scratch);
+ return new BinaryDocValuesAnonymousClass(this, field, input, scratch);
}
- private class BinaryDocValuesAnonymousInnerClassHelper : BinaryDocValues
+ private class BinaryDocValuesAnonymousClass : BinaryDocValues
{
private readonly SimpleTextDocValuesReader _outerInstance;
@@ -262,7 +262,7 @@ namespace Lucene.Net.Codecs.SimpleText
private readonly IndexInput _input;
private readonly BytesRef _scratch;
- public BinaryDocValuesAnonymousInnerClassHelper(SimpleTextDocValuesReader outerInstance, OneField field,
+ public BinaryDocValuesAnonymousClass(SimpleTextDocValuesReader outerInstance, OneField field,
IndexInput input, BytesRef scratch)
{
_outerInstance = outerInstance;
@@ -312,10 +312,10 @@ namespace Lucene.Net.Codecs.SimpleText
var input = (IndexInput)data.Clone();
var scratch = new BytesRef();
- return new BitsAnonymousInnerClassHelper2(this, field, input, scratch);
+ return new BitsAnonymousClass2(this, field, input, scratch);
}
- private class BitsAnonymousInnerClassHelper2 : IBits
+ private class BitsAnonymousClass2 : IBits
{
private readonly SimpleTextDocValuesReader _outerInstance;
@@ -323,7 +323,7 @@ namespace Lucene.Net.Codecs.SimpleText
private readonly IndexInput _input;
private readonly BytesRef _scratch;
- public BitsAnonymousInnerClassHelper2(SimpleTextDocValuesReader outerInstance, OneField field,
+ public BitsAnonymousClass2(SimpleTextDocValuesReader outerInstance, OneField field,
IndexInput input, BytesRef scratch)
{
_outerInstance = outerInstance;
@@ -375,10 +375,10 @@ namespace Lucene.Net.Codecs.SimpleText
var input = (IndexInput)data.Clone();
var scratch = new BytesRef();
- return new SortedDocValuesAnonymousInnerClassHelper(this, field, input, scratch);
+ return new SortedDocValuesAnonymousClass(this, field, input, scratch);
}
- private class SortedDocValuesAnonymousInnerClassHelper : SortedDocValues
+ private class SortedDocValuesAnonymousClass : SortedDocValues
{
private readonly SimpleTextDocValuesReader _outerInstance;
@@ -386,7 +386,7 @@ namespace Lucene.Net.Codecs.SimpleText
private readonly IndexInput _input;
private readonly BytesRef _scratch;
- public SortedDocValuesAnonymousInnerClassHelper(SimpleTextDocValuesReader outerInstance,
+ public SortedDocValuesAnonymousClass(SimpleTextDocValuesReader outerInstance,
OneField field, IndexInput input, BytesRef scratch)
{
_outerInstance = outerInstance;
@@ -476,10 +476,10 @@ namespace Lucene.Net.Codecs.SimpleText
var input = (IndexInput) data.Clone();
var scratch = new BytesRef();
- return new SortedSetDocValuesAnonymousInnerClassHelper(this, field, input, scratch);
+ return new SortedSetDocValuesAnonymousClass(this, field, input, scratch);
}
- private class SortedSetDocValuesAnonymousInnerClassHelper : SortedSetDocValues
+ private class SortedSetDocValuesAnonymousClass : SortedSetDocValues
{
private readonly SimpleTextDocValuesReader _outerInstance;
@@ -487,7 +487,7 @@ namespace Lucene.Net.Codecs.SimpleText
private readonly IndexInput _input;
private readonly BytesRef _scratch;
- public SortedSetDocValuesAnonymousInnerClassHelper(SimpleTextDocValuesReader outerInstance,
+ public SortedSetDocValuesAnonymousClass(SimpleTextDocValuesReader outerInstance,
OneField field, IndexInput input, BytesRef scratch)
{
_outerInstance = outerInstance;
diff --git a/src/Lucene.Net.Facet/DrillSidewaysQuery.cs b/src/Lucene.Net.Facet/DrillSidewaysQuery.cs
index 5bb8c70..123c90f 100644
--- a/src/Lucene.Net.Facet/DrillSidewaysQuery.cs
+++ b/src/Lucene.Net.Facet/DrillSidewaysQuery.cs
@@ -104,17 +104,17 @@ namespace Lucene.Net.Facet
}
}
- return new WeightAnonymousInnerClassHelper(this, baseWeight, drillDowns);
+ return new WeightAnonymousClass(this, baseWeight, drillDowns);
}
- private class WeightAnonymousInnerClassHelper : Weight
+ private class WeightAnonymousClass : Weight
{
private readonly DrillSidewaysQuery outerInstance;
private readonly Weight baseWeight;
private readonly object[] drillDowns;
- public WeightAnonymousInnerClassHelper(DrillSidewaysQuery outerInstance, Weight baseWeight, object[] drillDowns)
+ public WeightAnonymousClass(DrillSidewaysQuery outerInstance, Weight baseWeight, object[] drillDowns)
{
this.outerInstance = outerInstance;
this.baseWeight = baseWeight;
diff --git a/src/Lucene.Net.Facet/FacetsCollector.cs b/src/Lucene.Net.Facet/FacetsCollector.cs
index 41cc262..2c2d723 100644
--- a/src/Lucene.Net.Facet/FacetsCollector.cs
+++ b/src/Lucene.Net.Facet/FacetsCollector.cs
@@ -129,12 +129,12 @@ namespace Lucene.Net.Facet
/// </summary>
protected virtual Docs CreateDocs(int maxDoc)
{
- return new DocsAnonymousInnerClassHelper(maxDoc);
+ return new DocsAnonymousClass(maxDoc);
}
- private class DocsAnonymousInnerClassHelper : Docs
+ private class DocsAnonymousClass : Docs
{
- public DocsAnonymousInnerClassHelper(int maxDoc)
+ public DocsAnonymousClass(int maxDoc)
{
bits = new FixedBitSet(maxDoc);
}
diff --git a/src/Lucene.Net.Facet/Range/DoubleRange.cs b/src/Lucene.Net.Facet/Range/DoubleRange.cs
index eb2e8a1..606415f 100644
--- a/src/Lucene.Net.Facet/Range/DoubleRange.cs
+++ b/src/Lucene.Net.Facet/Range/DoubleRange.cs
@@ -123,17 +123,17 @@ namespace Lucene.Net.Facet.Range
public override Filter GetFilter(Filter fastMatchFilter, ValueSource valueSource)
{
- return new FilterAnonymousInnerClassHelper(this, fastMatchFilter, valueSource);
+ return new FilterAnonymousClass(this, fastMatchFilter, valueSource);
}
- private class FilterAnonymousInnerClassHelper : Filter
+ private class FilterAnonymousClass : Filter
{
private readonly DoubleRange outerInstance;
private readonly Filter fastMatchFilter;
private readonly ValueSource valueSource;
- public FilterAnonymousInnerClassHelper(DoubleRange outerInstance, Filter fastMatchFilter, ValueSource valueSource)
+ public FilterAnonymousClass(DoubleRange outerInstance, Filter fastMatchFilter, ValueSource valueSource)
{
this.outerInstance = outerInstance;
this.fastMatchFilter = fastMatchFilter;
@@ -177,19 +177,19 @@ namespace Lucene.Net.Facet.Range
fastMatchBits = null;
}
- return new DocIdSetAnonymousInnerClassHelper(this, acceptDocs, values, maxDoc, fastMatchBits);
+ return new DocIdSetAnonymousClass(this, acceptDocs, values, maxDoc, fastMatchBits);
}
- private class DocIdSetAnonymousInnerClassHelper : DocIdSet
+ private class DocIdSetAnonymousClass : DocIdSet
{
- private readonly FilterAnonymousInnerClassHelper outerInstance;
+ private readonly FilterAnonymousClass outerInstance;
private readonly IBits acceptDocs;
private readonly FunctionValues values;
private readonly int maxDoc;
private readonly IBits fastMatchBits;
- public DocIdSetAnonymousInnerClassHelper(FilterAnonymousInnerClassHelper outerInstance, IBits acceptDocs, FunctionValues values, int maxDoc, IBits fastMatchBits)
+ public DocIdSetAnonymousClass(FilterAnonymousClass outerInstance, IBits acceptDocs, FunctionValues values, int maxDoc, IBits fastMatchBits)
{
this.outerInstance = outerInstance;
this.acceptDocs = acceptDocs;
@@ -198,13 +198,13 @@ namespace Lucene.Net.Facet.Range
this.fastMatchBits = fastMatchBits;
}
- public override IBits Bits => new BitsAnonymousInnerClassHelper(this);
+ public override IBits Bits => new BitsAnonymousClass(this);
- private class BitsAnonymousInnerClassHelper : IBits
+ private class BitsAnonymousClass : IBits
{
- private readonly DocIdSetAnonymousInnerClassHelper outerInstance;
+ private readonly DocIdSetAnonymousClass outerInstance;
- public BitsAnonymousInnerClassHelper(DocIdSetAnonymousInnerClassHelper outerInstance)
+ public BitsAnonymousClass(DocIdSetAnonymousClass outerInstance)
{
this.outerInstance = outerInstance;
}
diff --git a/src/Lucene.Net.Facet/Range/LongRange.cs b/src/Lucene.Net.Facet/Range/LongRange.cs
index 0f3bfe8..026cb0d 100644
--- a/src/Lucene.Net.Facet/Range/LongRange.cs
+++ b/src/Lucene.Net.Facet/Range/LongRange.cs
@@ -117,17 +117,17 @@ namespace Lucene.Net.Facet.Range
public override Filter GetFilter(Filter fastMatchFilter, ValueSource valueSource)
{
- return new FilterAnonymousInnerClassHelper(this, fastMatchFilter, valueSource);
+ return new FilterAnonymousClass(this, fastMatchFilter, valueSource);
}
- private class FilterAnonymousInnerClassHelper : Filter
+ private class FilterAnonymousClass : Filter
{
private readonly Int64Range outerInstance;
private readonly Filter fastMatchFilter;
private readonly ValueSource valueSource;
- public FilterAnonymousInnerClassHelper(Int64Range outerInstance, Filter fastMatchFilter, ValueSource valueSource)
+ public FilterAnonymousClass(Int64Range outerInstance, Filter fastMatchFilter, ValueSource valueSource)
{
this.outerInstance = outerInstance;
this.fastMatchFilter = fastMatchFilter;
@@ -172,19 +172,19 @@ namespace Lucene.Net.Facet.Range
fastMatchBits = null;
}
- return new DocIdSetAnonymousInnerClassHelper(this, acceptDocs, values, maxDoc, fastMatchBits);
+ return new DocIdSetAnonymousClass(this, acceptDocs, values, maxDoc, fastMatchBits);
}
- private class DocIdSetAnonymousInnerClassHelper : DocIdSet
+ private class DocIdSetAnonymousClass : DocIdSet
{
- private readonly FilterAnonymousInnerClassHelper outerInstance;
+ private readonly FilterAnonymousClass outerInstance;
private readonly IBits acceptDocs;
private readonly FunctionValues values;
private readonly int maxDoc;
private readonly IBits fastMatchBits;
- public DocIdSetAnonymousInnerClassHelper(FilterAnonymousInnerClassHelper outerInstance, IBits acceptDocs, FunctionValues values, int maxDoc, IBits fastMatchBits)
+ public DocIdSetAnonymousClass(FilterAnonymousClass outerInstance, IBits acceptDocs, FunctionValues values, int maxDoc, IBits fastMatchBits)
{
this.outerInstance = outerInstance;
this.acceptDocs = acceptDocs;
@@ -194,13 +194,13 @@ namespace Lucene.Net.Facet.Range
}
- public override IBits Bits => new BitsAnonymousInnerClassHelper(this);
+ public override IBits Bits => new BitsAnonymousClass(this);
- private class BitsAnonymousInnerClassHelper : IBits
+ private class BitsAnonymousClass : IBits
{
- private readonly DocIdSetAnonymousInnerClassHelper outerInstance;
+ private readonly DocIdSetAnonymousClass outerInstance;
- public BitsAnonymousInnerClassHelper(DocIdSetAnonymousInnerClassHelper outerInstance)
+ public BitsAnonymousClass(DocIdSetAnonymousClass outerInstance)
{
this.outerInstance = outerInstance;
}
diff --git a/src/Lucene.Net.Facet/Taxonomy/CachedOrdinalsReader.cs b/src/Lucene.Net.Facet/Taxonomy/CachedOrdinalsReader.cs
index 7ffe9b5..7ff6132 100644
--- a/src/Lucene.Net.Facet/Taxonomy/CachedOrdinalsReader.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/CachedOrdinalsReader.cs
@@ -117,14 +117,14 @@ namespace Lucene.Net.Facet.Taxonomy
public override OrdinalsSegmentReader GetReader(AtomicReaderContext context)
{
CachedOrds cachedOrds = GetCachedOrds(context);
- return new OrdinalsSegmentReaderAnonymousInnerClassHelper(cachedOrds);
+ return new OrdinalsSegmentReaderAnonymousClass(cachedOrds);
}
- private class OrdinalsSegmentReaderAnonymousInnerClassHelper : OrdinalsSegmentReader
+ private class OrdinalsSegmentReaderAnonymousClass : OrdinalsSegmentReader
{
private readonly CachedOrds cachedOrds;
- public OrdinalsSegmentReaderAnonymousInnerClassHelper(CachedOrds cachedOrds)
+ public OrdinalsSegmentReaderAnonymousClass(CachedOrds cachedOrds)
{
this.cachedOrds = cachedOrds;
}
diff --git a/src/Lucene.Net.Facet/Taxonomy/DocValuesOrdinalsReader.cs b/src/Lucene.Net.Facet/Taxonomy/DocValuesOrdinalsReader.cs
index 6b42aa3..41359d9 100644
--- a/src/Lucene.Net.Facet/Taxonomy/DocValuesOrdinalsReader.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/DocValuesOrdinalsReader.cs
@@ -59,16 +59,16 @@ namespace Lucene.Net.Facet.Taxonomy
BinaryDocValues values = values0;
- return new OrdinalsSegmentReaderAnonymousInnerClassHelper(this, values);
+ return new OrdinalsSegmentReaderAnonymousClass(this, values);
}
- private class OrdinalsSegmentReaderAnonymousInnerClassHelper : OrdinalsSegmentReader
+ private class OrdinalsSegmentReaderAnonymousClass : OrdinalsSegmentReader
{
private readonly DocValuesOrdinalsReader outerInstance;
private readonly BinaryDocValues values;
- public OrdinalsSegmentReaderAnonymousInnerClassHelper(DocValuesOrdinalsReader outerInstance, BinaryDocValues values)
+ public OrdinalsSegmentReaderAnonymousClass(DocValuesOrdinalsReader outerInstance, BinaryDocValues values)
{
this.outerInstance = outerInstance;
this.values = values;
diff --git a/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetSumValueSource.cs b/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetSumValueSource.cs
index 218bf20..46ef005 100644
--- a/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetSumValueSource.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetSumValueSource.cs
@@ -167,14 +167,14 @@ namespace Lucene.Net.Facet.Taxonomy
{
throw new ThreadStateException("scores are missing; be sure to pass keepScores=true to FacetsCollector");
}
- return new DoubleDocValuesAnonymousInnerClassHelper(this, scorer);
+ return new DoubleDocValuesAnonymousClass(this, scorer);
}
- private class DoubleDocValuesAnonymousInnerClassHelper : DoubleDocValues
+ private class DoubleDocValuesAnonymousClass : DoubleDocValues
{
private readonly Scorer scorer;
- public DoubleDocValuesAnonymousInnerClassHelper(ScoreValueSource outerInstance, Scorer scorer)
+ public DoubleDocValuesAnonymousClass(ScoreValueSource outerInstance, Scorer scorer)
: base(outerInstance)
{
this.scorer = scorer;
diff --git a/src/Lucene.Net.Highlighter/PostingsHighlight/MultiTermHighlighting.cs b/src/Lucene.Net.Highlighter/PostingsHighlight/MultiTermHighlighting.cs
index 9af5ed8..8293e28 100644
--- a/src/Lucene.Net.Highlighter/PostingsHighlight/MultiTermHighlighting.cs
+++ b/src/Lucene.Net.Highlighter/PostingsHighlight/MultiTermHighlighting.cs
@@ -89,7 +89,7 @@ namespace Lucene.Net.Search.PostingsHighlight
{
if (aq.Field.Equals(field, StringComparison.Ordinal))
{
- list.Add(new CharacterRunAutomatonToStringAnonymousHelper(aq.Automaton, () => aq.ToString()));
+ list.Add(new CharacterRunAutomatonToStringAnonymousClass(aq.Automaton, () => aq.ToString()));
}
}
else if (query is PrefixQuery pq)
@@ -97,7 +97,7 @@ namespace Lucene.Net.Search.PostingsHighlight
Term prefix = pq.Prefix;
if (prefix.Field.Equals(field, StringComparison.Ordinal))
{
- list.Add(new CharacterRunAutomatonToStringAnonymousHelper(
+ list.Add(new CharacterRunAutomatonToStringAnonymousClass(
BasicOperations.Concatenate(BasicAutomata.MakeString(prefix.Text()), BasicAutomata.MakeAnyString()),
() => pq.ToString()));
}
@@ -122,7 +122,7 @@ namespace Lucene.Net.Search.PostingsHighlight
Automaton prefix = BasicAutomata.MakeString(UnicodeUtil.NewString(termText, 0, prefixLength));
automaton = BasicOperations.Concatenate(prefix, automaton);
}
- list.Add(new CharacterRunAutomatonToStringAnonymousHelper(automaton, () => fq.ToString()));
+ list.Add(new CharacterRunAutomatonToStringAnonymousClass(automaton, () => fq.ToString()));
}
}
else if (query is TermRangeQuery tq)
@@ -130,17 +130,17 @@ namespace Lucene.Net.Search.PostingsHighlight
if (tq.Field.Equals(field, StringComparison.Ordinal))
{
// this is *not* an automaton, but its very simple
- list.Add(new SimpleCharacterRunAutomatonAnonymousHelper(BasicAutomata.MakeEmpty(), tq));
+ list.Add(new SimpleCharacterRunAutomatonAnonymousClass(BasicAutomata.MakeEmpty(), tq));
}
}
return list.ToArray(/*new CharacterRunAutomaton[list.size()]*/);
}
- internal class CharacterRunAutomatonToStringAnonymousHelper : CharacterRunAutomaton
+ internal class CharacterRunAutomatonToStringAnonymousClass : CharacterRunAutomaton
{
private readonly Func<string> toStringMethod;
- public CharacterRunAutomatonToStringAnonymousHelper(Automaton a, Func<string> toStringMethod)
+ public CharacterRunAutomatonToStringAnonymousClass(Automaton a, Func<string> toStringMethod)
: base(a)
{
this.toStringMethod = toStringMethod;
@@ -152,7 +152,7 @@ namespace Lucene.Net.Search.PostingsHighlight
}
}
- internal class SimpleCharacterRunAutomatonAnonymousHelper : CharacterRunAutomaton
+ internal class SimpleCharacterRunAutomatonAnonymousClass : CharacterRunAutomaton
{
private readonly CharsRef lowerBound;
private readonly CharsRef upperBound;
@@ -163,7 +163,7 @@ namespace Lucene.Net.Search.PostingsHighlight
private static readonly IComparer<CharsRef> comparer = CharsRef.UTF16SortedAsUTF8Comparer; // LUCENENET specific - made static
#pragma warning restore 612, 618
- public SimpleCharacterRunAutomatonAnonymousHelper(Automaton a, TermRangeQuery tq)
+ public SimpleCharacterRunAutomatonAnonymousClass(Automaton a, TermRangeQuery tq)
: base(a)
{
if (tq.LowerTerm == null)
@@ -230,16 +230,16 @@ namespace Lucene.Net.Search.PostingsHighlight
// would only serve to make this method less bogus.
// instead, we always return freq() = Integer.MAX_VALUE and let PH terminate based on offset...
- return new DocsAndPositionsEnumAnonymousHelper(ts, matchers, charTermAtt, offsetAtt);
+ return new DocsAndPositionsEnumAnonymousClass(ts, matchers, charTermAtt, offsetAtt);
}
- internal class DocsAndPositionsEnumAnonymousHelper : DocsAndPositionsEnum
+ internal class DocsAndPositionsEnumAnonymousClass : DocsAndPositionsEnum
{
private readonly CharacterRunAutomaton[] matchers;
private readonly ICharTermAttribute charTermAtt;
private readonly IOffsetAttribute offsetAtt;
- public DocsAndPositionsEnumAnonymousHelper(
+ public DocsAndPositionsEnumAnonymousClass(
TokenStream ts, CharacterRunAutomaton[] matchers, ICharTermAttribute charTermAtt, IOffsetAttribute offsetAtt)
{
this.matchers = matchers;
diff --git a/src/Lucene.Net.Highlighter/PostingsHighlight/Passage.cs b/src/Lucene.Net.Highlighter/PostingsHighlight/Passage.cs
index fa0f236..9239a65 100644
--- a/src/Lucene.Net.Highlighter/PostingsHighlight/Passage.cs
+++ b/src/Lucene.Net.Highlighter/PostingsHighlight/Passage.cs
@@ -64,13 +64,13 @@ namespace Lucene.Net.Search.PostingsHighlight
numMatches++;
}
- internal class InPlaceMergeSorterAnonymousHelper : InPlaceMergeSorter
+ internal class InPlaceMergeSorterAnonymousClass : InPlaceMergeSorter
{
private readonly int[] starts;
private readonly int[] ends;
private readonly BytesRef[] terms;
- public InPlaceMergeSorterAnonymousHelper(int[] starts, int[] ends, BytesRef[] terms)
+ public InPlaceMergeSorterAnonymousClass(int[] starts, int[] ends, BytesRef[] terms)
{
this.starts = starts;
this.ends = ends;
@@ -103,7 +103,7 @@ namespace Lucene.Net.Search.PostingsHighlight
int[] starts = matchStarts;
int[] ends = matchEnds;
BytesRef[] terms = matchTerms;
- new InPlaceMergeSorterAnonymousHelper(starts, ends, terms)
+ new InPlaceMergeSorterAnonymousClass(starts, ends, terms)
.Sort(0, numMatches);
}
diff --git a/src/Lucene.Net.Highlighter/PostingsHighlight/PostingsHighlighter.cs b/src/Lucene.Net.Highlighter/PostingsHighlight/PostingsHighlighter.cs
index 1ec4c65..d145f21 100644
--- a/src/Lucene.Net.Highlighter/PostingsHighlight/PostingsHighlighter.cs
+++ b/src/Lucene.Net.Highlighter/PostingsHighlight/PostingsHighlighter.cs
@@ -333,11 +333,11 @@ namespace Lucene.Net.Search.PostingsHighlight
return snippets;
}
- internal class InPlaceMergeSorterAnonymousHelper : InPlaceMergeSorter
+ internal class InPlaceMergeSorterAnonymousClass : InPlaceMergeSorter
{
private readonly string[] fields;
private readonly int[] maxPassages;
- public InPlaceMergeSorterAnonymousHelper(string[] fields, int[] maxPassages)
+ public InPlaceMergeSorterAnonymousClass(string[] fields, int[] maxPassages)
{
this.fields = fields;
this.maxPassages = maxPassages;
@@ -407,7 +407,7 @@ namespace Lucene.Net.Search.PostingsHighlight
// sort for sequential io
ArrayUtil.TimSort(docids);
- new InPlaceMergeSorterAnonymousHelper(fields, maxPassages).Sort(0, fields.Length);
+ new InPlaceMergeSorterAnonymousClass(fields, maxPassages).Sort(0, fields.Length);
// pull stored data:
IList<string[]> contents = LoadFieldValues(searcher, fields, docids, maxLength);
@@ -819,13 +819,13 @@ namespace Lucene.Net.Search.PostingsHighlight
}
}
- private static readonly DocsAndPositionsEnum EMPTY = new DocsAndPositionsEnumAnonymousHelper();
+ private static readonly DocsAndPositionsEnum EMPTY = new DocsAndPositionsEnumAnonymousClass();
/// <summary>
/// we rewrite against an empty indexreader: as we don't want things like
/// rangeQueries that don't summarize the document
/// </summary>
- private class DocsAndPositionsEnumAnonymousHelper : DocsAndPositionsEnum
+ private class DocsAndPositionsEnumAnonymousClass : DocsAndPositionsEnum
{
public override int NextPosition()
{
diff --git a/src/Lucene.Net.Highlighter/VectorHighlight/BaseFragmentsBuilder.cs b/src/Lucene.Net.Highlighter/VectorHighlight/BaseFragmentsBuilder.cs
index 16eeb0d..9002537 100644
--- a/src/Lucene.Net.Highlighter/VectorHighlight/BaseFragmentsBuilder.cs
+++ b/src/Lucene.Net.Highlighter/VectorHighlight/BaseFragmentsBuilder.cs
@@ -151,16 +151,16 @@ namespace Lucene.Net.Search.VectorHighlight
{
// according to javadoc, doc.getFields(fieldName) cannot be used with lazy loaded field???
List<Field> fields = new List<Field>();
- reader.Document(docId, new GetFieldsStoredFieldsVisitorAnonymousHelper(fields, fieldName));
+ reader.Document(docId, new GetFieldsStoredFieldsVisitorAnonymousClass(fields, fieldName));
return fields.ToArray(/*new Field[fields.size()]*/);
}
- internal class GetFieldsStoredFieldsVisitorAnonymousHelper : StoredFieldVisitor
+ internal class GetFieldsStoredFieldsVisitorAnonymousClass : StoredFieldVisitor
{
private readonly IList<Field> fields;
private readonly string fieldName;
- public GetFieldsStoredFieldsVisitorAnonymousHelper(IList<Field> fields, string fieldName)
+ public GetFieldsStoredFieldsVisitorAnonymousClass(IList<Field> fields, string fieldName)
{
this.fields = fields;
this.fieldName = fieldName;
diff --git a/src/Lucene.Net.Join/TermsIncludingScoreQuery.cs b/src/Lucene.Net.Join/TermsIncludingScoreQuery.cs
index 8b1eb1a..7725045 100644
--- a/src/Lucene.Net.Join/TermsIncludingScoreQuery.cs
+++ b/src/Lucene.Net.Join/TermsIncludingScoreQuery.cs
@@ -117,16 +117,16 @@ namespace Lucene.Net.Join
public override Weight CreateWeight(IndexSearcher searcher)
{
Weight originalWeight = _originalQuery.CreateWeight(searcher);
- return new WeightAnonymousInnerClassHelper(this, originalWeight);
+ return new WeightAnonymousClass(this, originalWeight);
}
- private class WeightAnonymousInnerClassHelper : Weight
+ private class WeightAnonymousClass : Weight
{
private readonly TermsIncludingScoreQuery outerInstance;
private readonly Weight originalWeight;
- public WeightAnonymousInnerClassHelper(TermsIncludingScoreQuery outerInstance, Weight originalWeight)
+ public WeightAnonymousClass(TermsIncludingScoreQuery outerInstance, Weight originalWeight)
{
this.outerInstance = outerInstance;
this.originalWeight = originalWeight;
diff --git a/src/Lucene.Net.Memory/MemoryIndex.MemoryIndexReader.cs b/src/Lucene.Net.Memory/MemoryIndex.MemoryIndexReader.cs
index a05ac8c..6ff3c01 100644
--- a/src/Lucene.Net.Memory/MemoryIndex.MemoryIndexReader.cs
+++ b/src/Lucene.Net.Memory/MemoryIndex.MemoryIndexReader.cs
@@ -107,14 +107,14 @@ namespace Lucene.Net.Index.Memory
public override IEnumerator<string> GetEnumerator()
{
- return new IteratorAnonymousInnerClassHelper(this);
+ return new IteratorAnonymousClass(this);
}
- private class IteratorAnonymousInnerClassHelper : IEnumerator<string>
+ private class IteratorAnonymousClass : IEnumerator<string>
{
private readonly MemoryFields outerInstance;
- public IteratorAnonymousInnerClassHelper(MemoryFields outerInstance)
+ public IteratorAnonymousClass(MemoryFields outerInstance)
{
this.outerInstance = outerInstance;
upto = -1;
@@ -162,17 +162,17 @@ namespace Lucene.Net.Index.Memory
Info info = outerInstance.GetInfo(i);
info.SortTerms();
- return new TermsAnonymousInnerClassHelper(this, info);
+ return new TermsAnonymousClass(this, info);
}
}
- private class TermsAnonymousInnerClassHelper : Terms
+ private class TermsAnonymousClass : Terms
{
private readonly MemoryFields outerInstance;
private readonly MemoryIndex.Info info;
- public TermsAnonymousInnerClassHelper(MemoryFields outerInstance, MemoryIndex.Info info)
+ public TermsAnonymousClass(MemoryFields outerInstance, MemoryIndex.Info info)
{
this.outerInstance = outerInstance;
this.info = info;
diff --git a/src/Lucene.Net.Memory/MemoryIndex.cs b/src/Lucene.Net.Memory/MemoryIndex.cs
index eaba454..f792302 100644
--- a/src/Lucene.Net.Memory/MemoryIndex.cs
+++ b/src/Lucene.Net.Memory/MemoryIndex.cs
@@ -277,12 +277,12 @@ namespace Lucene.Net.Index.Memory
throw new ArgumentException("keywords must not be null");
}
- return new TokenStreamAnonymousInnerClassHelper<T>(keywords);
+ return new TokenStreamAnonymousClass<T>(keywords);
}
- private sealed class TokenStreamAnonymousInnerClassHelper<T> : TokenStream
+ private sealed class TokenStreamAnonymousClass<T> : TokenStream
{
- public TokenStreamAnonymousInnerClassHelper(ICollection<T> keywords)
+ public TokenStreamAnonymousClass(ICollection<T> keywords)
{
iter = keywords.GetEnumerator();
start = 0;
@@ -317,7 +317,7 @@ namespace Lucene.Net.Index.Memory
}
/// <summary>
- /// Releases resources used by the <see cref="TokenStreamAnonymousInnerClassHelper{T}"/> and
+ /// Releases resources used by the <see cref="TokenStreamAnonymousClass{T}"/> and
/// if overridden in a derived class, optionally releases unmanaged resources.
/// </summary>
/// <param name="disposing"><c>true</c> to release both managed and unmanaged resources;
@@ -557,7 +557,7 @@ namespace Lucene.Net.Index.Memory
try
{
float[] scores = new float[1]; // inits to 0.0f (no match)
- searcher.Search(query, new CollectorAnonymousInnerClassHelper(scores));
+ searcher.Search(query, new CollectorAnonymousClass(scores));
float score = scores[0];
return score;
} // can never happen (RAMDirectory)
@@ -584,11 +584,11 @@ namespace Lucene.Net.Index.Memory
}
}
- private class CollectorAnonymousInnerClassHelper : ICollector
+ private class CollectorAnonymousClass : ICollector
{
private readonly float[] scores;
- public CollectorAnonymousInnerClassHelper(float[] scores)
+ public CollectorAnonymousClass(float[] scores)
{
this.scores = scores;
}
diff --git a/src/Lucene.Net.Misc/Index/Sorter/BlockJoinComparatorSource.cs b/src/Lucene.Net.Misc/Index/Sorter/BlockJoinComparatorSource.cs
index cf41032..136b67f 100644
--- a/src/Lucene.Net.Misc/Index/Sorter/BlockJoinComparatorSource.cs
+++ b/src/Lucene.Net.Misc/Index/Sorter/BlockJoinComparatorSource.cs
@@ -95,11 +95,11 @@ namespace Lucene.Net.Index.Sorter
// NOTE: we could return parent ID as value but really our sort "value" is more complex...
// So we throw UOE for now. At the moment you really should only use this at indexing time.
- return new FieldComparerAnonymousInnerClassHelper(this, parentSlots,
+ return new FieldComparerAnonymousClass(this, parentSlots,
childSlots, parentReverseMul, parentComparers, childReverseMul, childComparers);
}
- private class FieldComparerAnonymousInnerClassHelper : FieldComparer<int?>
+ private class FieldComparerAnonymousClass : FieldComparer<int?>
{
private readonly BlockJoinComparerSource outerInstance;
@@ -110,7 +110,7 @@ namespace Lucene.Net.Index.Sorter
private readonly int[] childReverseMul;
private readonly FieldComparer[] childComparers;
- public FieldComparerAnonymousInnerClassHelper(BlockJoinComparerSource outerInstance,
+ public FieldComparerAnonymousClass(BlockJoinComparerSource outerInstance,
int[] parentSlots, int[] childSlots, int[] parentReverseMul, FieldComparer[] parentComparers,
int[] childReverseMul, FieldComparer[] childComparers)
{
diff --git a/src/Lucene.Net.Misc/Index/Sorter/Sorter.cs b/src/Lucene.Net.Misc/Index/Sorter/Sorter.cs
index a6abc79..ddc77a0 100644
--- a/src/Lucene.Net.Misc/Index/Sorter/Sorter.cs
+++ b/src/Lucene.Net.Misc/Index/Sorter/Sorter.cs
@@ -209,16 +209,16 @@ namespace Lucene.Net.Index.Sorter
}
oldToNew.Freeze();
- return new DocMapAnonymousInnerClassHelper(maxDoc, newToOld, oldToNew);
+ return new DocMapAnonymousClass(maxDoc, newToOld, oldToNew);
}
- private class DocMapAnonymousInnerClassHelper : Sorter.DocMap
+ private class DocMapAnonymousClass : Sorter.DocMap
{
private readonly int maxDoc;
private readonly MonotonicAppendingInt64Buffer newToOld;
private readonly MonotonicAppendingInt64Buffer oldToNew;
- public DocMapAnonymousInnerClassHelper(int maxDoc, MonotonicAppendingInt64Buffer newToOld, MonotonicAppendingInt64Buffer oldToNew)
+ public DocMapAnonymousClass(int maxDoc, MonotonicAppendingInt64Buffer newToOld, MonotonicAppendingInt64Buffer oldToNew)
{
this.maxDoc = maxDoc;
this.newToOld = newToOld;
@@ -266,16 +266,16 @@ namespace Lucene.Net.Index.Sorter
comparers[i].SetNextReader(reader.AtomicContext);
comparers[i].SetScorer(FAKESCORER);
}
- DocComparer comparer = new DocComparerAnonymousInnerClassHelper(reverseMul, comparers);
+ DocComparer comparer = new DocComparerAnonymousClass(reverseMul, comparers);
return Sort(reader.MaxDoc, comparer);
}
- private class DocComparerAnonymousInnerClassHelper : DocComparer
+ private class DocComparerAnonymousClass : DocComparer
{
private readonly int[] reverseMul;
private readonly FieldComparer[] comparers;
- public DocComparerAnonymousInnerClassHelper(int[] reverseMul, FieldComparer[] comparers)
+ public DocComparerAnonymousClass(int[] reverseMul, FieldComparer[] comparers)
{
this.reverseMul = reverseMul;
this.comparers = comparers;
@@ -321,11 +321,11 @@ namespace Lucene.Net.Index.Sorter
return ID;
}
- internal static readonly Scorer FAKESCORER = new ScorerAnonymousInnerClassHelper();
+ internal static readonly Scorer FAKESCORER = new ScorerAnonymousClass();
- private class ScorerAnonymousInnerClassHelper : Scorer
+ private class ScorerAnonymousClass : Scorer
{
- public ScorerAnonymousInnerClassHelper()
+ public ScorerAnonymousClass()
: base(null)
{
}
diff --git a/src/Lucene.Net.Misc/Index/Sorter/SortingAtomicReader.cs b/src/Lucene.Net.Misc/Index/Sorter/SortingAtomicReader.cs
index 2be2a78..ff93a6d 100644
--- a/src/Lucene.Net.Misc/Index/Sorter/SortingAtomicReader.cs
+++ b/src/Lucene.Net.Misc/Index/Sorter/SortingAtomicReader.cs
@@ -117,16 +117,16 @@ namespace Lucene.Net.Index.Sorter
{
return null;
}
- return new BitsAnonymousInnerClassHelper(this, liveDocs);
+ return new BitsAnonymousClass(this, liveDocs);
}
- private class BitsAnonymousInnerClassHelper : IBits
+ private class BitsAnonymousClass : IBits
{
private readonly SortingTermsEnum outerInstance;
private readonly IBits liveDocs;
- public BitsAnonymousInnerClassHelper(SortingTermsEnum outerInstance, IBits liveDocs)
+ public BitsAnonymousClass(SortingTermsEnum outerInstance, IBits liveDocs)
{
this.outerInstance = outerInstance;
this.liveDocs = liveDocs;
diff --git a/src/Lucene.Net.Misc/Index/Sorter/SortingMergePolicy.cs b/src/Lucene.Net.Misc/Index/Sorter/SortingMergePolicy.cs
index ceae5b6..65a40d0 100644
--- a/src/Lucene.Net.Misc/Index/Sorter/SortingMergePolicy.cs
+++ b/src/Lucene.Net.Misc/Index/Sorter/SortingMergePolicy.cs
@@ -136,17 +136,17 @@ namespace Lucene.Net.Index.Sorter
}
if (Debugging.AssertsEnabled) Debugging.Assert(mergeState.DocMaps.Length == 1); // we returned a singleton reader
MonotonicAppendingInt64Buffer deletes = GetDeletes(unsortedReaders);
- return new DocMapAnonymousInnerClassHelper(this, mergeState, deletes);
+ return new DocMapAnonymousClass(this, mergeState, deletes);
}
- private class DocMapAnonymousInnerClassHelper : MergePolicy.DocMap
+ private class DocMapAnonymousClass : MergePolicy.DocMap
{
private readonly SortingOneMerge outerInstance;
private readonly MergeState mergeState;
private readonly MonotonicAppendingInt64Buffer deletes;
- public DocMapAnonymousInnerClassHelper(SortingOneMerge outerInstance, MergeState mergeState, MonotonicAppendingInt64Buffer deletes)
+ public DocMapAnonymousClass(SortingOneMerge outerInstance, MergeState mergeState, MonotonicAppendingInt64Buffer deletes)
{
this.outerInstance = outerInstance;
this.mergeState = mergeState;
diff --git a/src/Lucene.Net.Queries/BoostingQuery.cs b/src/Lucene.Net.Queries/BoostingQuery.cs
index c191150..7a6c142 100644
--- a/src/Lucene.Net.Queries/BoostingQuery.cs
+++ b/src/Lucene.Net.Queries/BoostingQuery.cs
@@ -53,32 +53,32 @@ namespace Lucene.Net.Queries
public override Query Rewrite(IndexReader reader)
{
- return new BooleanQueryAnonymousInnerClassHelper(this)
+ return new BooleanQueryAnonymousClass(this)
{
{ match, Occur.MUST },
{ context, Occur.SHOULD }
};
}
- private class BooleanQueryAnonymousInnerClassHelper : BooleanQuery
+ private class BooleanQueryAnonymousClass : BooleanQuery
{
private readonly BoostingQuery outerInstance;
- public BooleanQueryAnonymousInnerClassHelper(BoostingQuery outerInstance)
+ public BooleanQueryAnonymousClass(BoostingQuery outerInstance)
{
this.outerInstance = outerInstance;
}
public override Weight CreateWeight(IndexSearcher searcher)
{
- return new BooleanWeightAnonymousInnerClassHelper(this, searcher);
+ return new BooleanWeightAnonymousClass(this, searcher);
}
- private class BooleanWeightAnonymousInnerClassHelper : BooleanWeight
+ private class BooleanWeightAnonymousClass : BooleanWeight
{
- private readonly BooleanQueryAnonymousInnerClassHelper outerInstance;
+ private readonly BooleanQueryAnonymousClass outerInstance;
- public BooleanWeightAnonymousInnerClassHelper(BooleanQueryAnonymousInnerClassHelper outerInstance, IndexSearcher searcher)
+ public BooleanWeightAnonymousClass(BooleanQueryAnonymousClass outerInstance, IndexSearcher searcher)
: base(outerInstance, searcher, false)
{
this.outerInstance = outerInstance;
diff --git a/src/Lucene.Net.Queries/Function/ValueSources/ByteFieldSource.cs b/src/Lucene.Net.Queries/Function/ValueSources/ByteFieldSource.cs
index 9628298..5279ffe 100644
--- a/src/Lucene.Net.Queries/Function/ValueSources/ByteFieldSource.cs
+++ b/src/Lucene.Net.Queries/Function/ValueSources/ByteFieldSource.cs
@@ -53,15 +53,15 @@ namespace Lucene.Net.Queries.Function.ValueSources
{
FieldCache.Bytes arr = m_cache.GetBytes(readerContext.AtomicReader, m_field, parser, false);
- return new FunctionValuesAnonymousInnerClassHelper(this, arr);
+ return new FunctionValuesAnonymousClass(this, arr);
}
- private class FunctionValuesAnonymousInnerClassHelper : FunctionValues
+ private class FunctionValuesAnonymousClass : FunctionValues
{
private readonly ByteFieldSource outerInstance;
private readonly FieldCache.Bytes arr;
- public FunctionValuesAnonymousInnerClassHelper(ByteFieldSource outerInstance, FieldCache.Bytes arr)
+ public FunctionValuesAnonymousClass(ByteFieldSource outerInstance, FieldCache.Bytes arr)
{
this.outerInstance = outerInstance;
this.arr = arr;
diff --git a/src/Lucene.Net.Queries/Function/ValueSources/BytesRefFieldSource.cs b/src/Lucene.Net.Queries/Function/ValueSources/BytesRefFieldSource.cs
index 2e137c9..1903796 100644
--- a/src/Lucene.Net.Queries/Function/ValueSources/BytesRefFieldSource.cs
+++ b/src/Lucene.Net.Queries/Function/ValueSources/BytesRefFieldSource.cs
@@ -42,22 +42,22 @@ namespace Lucene.Net.Queries.Function.ValueSources
{
BinaryDocValues binaryValues = Search.FieldCache.DEFAULT.GetTerms(readerContext.AtomicReader, m_field, true);
IBits docsWithField = Search.FieldCache.DEFAULT.GetDocsWithField(readerContext.AtomicReader, m_field);
- return new FunctionValuesAnonymousInnerClassHelper(this, binaryValues, docsWithField);
+ return new FunctionValuesAnonymousClass(this, binaryValues, docsWithField);
}
else
{
- return new DocTermsIndexDocValuesAnonymousInnerClassHelper(this, this, readerContext, m_field);
+ return new DocTermsIndexDocValuesAnonymousClass(this, this, readerContext, m_field);
}
}
- private class FunctionValuesAnonymousInnerClassHelper : FunctionValues
+ private class FunctionValuesAnonymousClass : FunctionValues
{
private readonly BytesRefFieldSource outerInstance;
private readonly BinaryDocValues binaryValues;
private readonly IBits docsWithField;
- public FunctionValuesAnonymousInnerClassHelper(BytesRefFieldSource outerInstance, BinaryDocValues binaryValues, IBits docsWithField)
+ public FunctionValuesAnonymousClass(BytesRefFieldSource outerInstance, BinaryDocValues binaryValues, IBits docsWithField)
{
this.outerInstance = outerInstance;
this.binaryValues = binaryValues;
@@ -93,11 +93,11 @@ namespace Lucene.Net.Queries.Function.ValueSources
}
}
- private class DocTermsIndexDocValuesAnonymousInnerClassHelper : DocTermsIndexDocValues
+ private class DocTermsIndexDocValuesAnonymousClass : DocTermsIndexDocValues
{
private readonly BytesRefFieldSource outerInstance;
- public DocTermsIndexDocValuesAnonymousInnerClassHelper(BytesRefFieldSource outerInstance, BytesRefFieldSource @this, AtomicReaderContext readerContext, string field)
+ public DocTermsIndexDocValuesAnonymousClass(BytesRefFieldSource outerInstance, BytesRefFieldSource @this, AtomicReaderContext readerContext, string field)
: base(@this, readerContext, field)
{
this.outerInstance = outerInstance;
diff --git a/src/Lucene.Net.Queries/Function/ValueSources/ConstValueSource.cs b/src/Lucene.Net.Queries/Function/ValueSources/ConstValueSource.cs
index d448348..607bd57 100644
--- a/src/Lucene.Net.Queries/Function/ValueSources/ConstValueSource.cs
+++ b/src/Lucene.Net.Queries/Function/ValueSources/ConstValueSource.cs
@@ -42,14 +42,14 @@ namespace Lucene.Net.Queries.Function.ValueSources
public override FunctionValues GetValues(IDictionary context, AtomicReaderContext readerContext)
{
- return new SingleDocValuesAnonymousInnerClassHelper(this, this);
+ return new SingleDocValuesAnonymousClass(this, this);
}
- private class SingleDocValuesAnonymousInnerClassHelper : SingleDocValues
+ private class SingleDocValuesAnonymousClass : SingleDocValues
{
private readonly ConstValueSource outerInstance;
- public SingleDocValuesAnonymousInnerClassHelper(ConstValueSource outerInstance, ConstValueSource @this)
+ public SingleDocValuesAnonymousClass(ConstValueSource outerInstance, ConstValueSource @this)
: base(@this)
{
this.outerInstance = outerInstance;
diff --git a/src/Lucene.Net.Queries/Function/ValueSources/DefFunction.cs b/src/Lucene.Net.Queries/Function/ValueSources/DefFunction.cs
index 40cf6b9..b12c4c8 100644
--- a/src/Lucene.Net.Queries/Function/ValueSources/DefFunction.cs
+++ b/src/Lucene.Net.Queries/Function/ValueSources/DefFunction.cs
@@ -39,12 +39,12 @@ namespace Lucene.Net.Queries.Function.ValueSources
public override FunctionValues GetValues(IDictionary fcontext, AtomicReaderContext readerContext)
{
- return new ValuesAnonymousInnerClassHelper(this, ValsArr(m_sources, fcontext, readerContext));
+ return new ValuesAnonymousClass(this, ValsArr(m_sources, fcontext, readerContext));
}
- private class ValuesAnonymousInnerClassHelper : Values
+ private class ValuesAnonymousClass : Values
{
- public ValuesAnonymousInnerClassHelper(DefFunction outerInstance, FunctionValues[] valsArr)
+ public ValuesAnonymousClass(DefFunction outerInstance, FunctionValues[] valsArr)
: base(outerInstance, valsArr)
{
upto = valsArr.Length - 1;
diff --git a/src/Lucene.Net.Queries/Function/ValueSources/DoubleConstValueSource.cs b/src/Lucene.Net.Queries/Function/ValueSources/DoubleConstValueSource.cs
index 3b9cdb1..f7b8d02 100644
--- a/src/Lucene.Net.Queries/Function/ValueSources/DoubleConstValueSource.cs
+++ b/src/Lucene.Net.Queries/Function/ValueSources/DoubleConstValueSource.cs
@@ -47,14 +47,14 @@ namespace Lucene.Net.Queries.Function.ValueSources
public override FunctionValues GetValues(IDictionary context, AtomicReaderContext readerContext)
{
- return new DoubleDocValuesAnonymousInnerClassHelper(this, this);
+ return new DoubleDocValuesAnonymousClass(this, this);
}
- private class DoubleDocValuesAnonymousInnerClassHelper : DoubleDocValues
+ private class DoubleDocValuesAnonymousClass : DoubleDocValues
{
private readonly DoubleConstValueSource outerInstance;
- public DoubleDocValuesAnonymousInnerClassHelper(DoubleConstValueSource outerInstance, DoubleConstValueSource @this)
+ public DoubleDocValuesAnonymousClass(DoubleConstValueSource outerInstance, DoubleConstValueSource @this)
: base(@this)
{
this.outerInstance = outerInstance;
diff --git a/src/Lucene.Net.Queries/Function/ValueSources/DoubleFieldSource.cs b/src/Lucene.Net.Queries/Function/ValueSources/DoubleFieldSource.cs
index d721773..a823e52 100644
--- a/src/Lucene.Net.Queries/Function/ValueSources/DoubleFieldSource.cs
+++ b/src/Lucene.Net.Queries/Function/ValueSources/DoubleFieldSource.cs
@@ -52,15 +52,15 @@ namespace Lucene.Net.Queries.Function.ValueSources
{
var arr = m_cache.GetDoubles(readerContext.AtomicReader, m_field, m_parser, true);
var valid = m_cache.GetDocsWithField(readerContext.AtomicReader, m_field);
- return new DoubleDocValuesAnonymousInnerClassHelper(this, arr, valid);
+ return new DoubleDocValuesAnonymousClass(this, arr, valid);
}
- private class DoubleDocValuesAnonymousInnerClassHelper : DoubleDocValues
+ private class DoubleDocValuesAnonymousClass : DoubleDocValues
{
private readonly FieldCache.Doubles arr;
private readonly IBits valid;
- public DoubleDocValuesAnonymousInnerClassHelper(DoubleFieldSource @this, FieldCache.Doubles arr, IBits valid)
+ public DoubleDocValuesAnonymousClass(DoubleFieldSource @this, FieldCache.Doubles arr, IBits valid)
: base(@this)
{
this.arr = arr;
diff --git a/src/Lucene.Net.Queries/Function/ValueSources/DualFloatFunction.cs b/src/Lucene.Net.Queries/Function/ValueSources/DualFloatFunction.cs
index e13574e..fc69e47 100644
--- a/src/Lucene.Net.Queries/Function/ValueSources/DualFloatFunction.cs
+++ b/src/Lucene.Net.Queries/Function/ValueSources/DualFloatFunction.cs
@@ -54,17 +54,17 @@ namespace Lucene.Net.Queries.Function.ValueSources
{
FunctionValues aVals = m_a.GetValues(context, readerContext);
FunctionValues bVals = m_b.GetValues(context, readerContext);
- return new SingleDocValuesAnonymousInnerClassHelper(this, this, aVals, bVals);
+ return new SingleDocValuesAnonymousClass(this, this, aVals, bVals);
}
- private class SingleDocValuesAnonymousInnerClassHelper : SingleDocValues
+ private class SingleDocValuesAnonymousClass : SingleDocValues
{
private readonly DualSingleFunction outerInstance;
private readonly FunctionValues aVals;
private readonly FunctionValues bVals;
- public SingleDocValuesAnonymousInnerClassHelper(DualSingleFunction outerInstance, DualSingleFunction @this, FunctionValues aVals, FunctionValues bVals)
+ public SingleDocValuesAnonymousClass(DualSingleFunction outerInstance, DualSingleFunction @this, FunctionValues aVals, FunctionValues bVals)
: base(@this)
{
this.outerInstance = outerInstance;
diff --git a/src/Lucene.Net.Queries/Function/ValueSources/EnumFieldSource.cs b/src/Lucene.Net.Queries/Function/ValueSources/EnumFieldSource.cs
index b95cf8d..c1dc8ef 100644
--- a/src/Lucene.Net.Queries/Function/ValueSources/EnumFieldSource.cs
+++ b/src/Lucene.Net.Queries/Function/ValueSources/EnumFieldSource.cs
@@ -110,17 +110,17 @@ namespace Lucene.Net.Queries.Function.ValueSources
var arr = m_cache.GetInt32s(readerContext.AtomicReader, m_field, parser, true);
var valid = m_cache.GetDocsWithField(readerContext.AtomicReader, m_field);
- return new Int32DocValuesAnonymousInnerClassHelper(this, this, arr, valid);
+ return new Int32DocValuesAnonymousClass(this, this, arr, valid);
}
- private class Int32DocValuesAnonymousInnerClassHelper : Int32DocValues
+ private class Int32DocValuesAnonymousClass : Int32DocValues
{
private readonly EnumFieldSource outerInstance;
private readonly FieldCache.Int32s arr;
private readonly IBits valid;
- public Int32DocValuesAnonymousInnerClassHelper(EnumFieldSource outerInstance, EnumFieldSource @this, FieldCache.Int32s arr, IBits valid)
+ public Int32DocValuesAnonymousClass(EnumFieldSource outerInstance, EnumFieldSource @this, FieldCache.Int32s arr, IBits valid)
: base(@this)
{
this.outerInstance = outerInstance;
diff --git a/src/Lucene.Net.Queries/Function/ValueSources/FloatFieldSource.cs b/src/Lucene.Net.Queries/Function/ValueSources/FloatFieldSource.cs
index ffb4f8c..f09a127 100644
--- a/src/Lucene.Net.Queries/Function/ValueSources/FloatFieldSource.cs
+++ b/src/Lucene.Net.Queries/Function/ValueSources/FloatFieldSource.cs
@@ -54,15 +54,15 @@ namespace Lucene.Net.Queries.Function.ValueSources
{
var arr = m_cache.GetSingles(readerContext.AtomicReader, m_field, m_parser, true);
var valid = m_cache.GetDocsWithField(readerContext.AtomicReader, m_field);
- return new SingleDocValuesAnonymousInnerClassHelper(this, arr, valid);
+ return new SingleDocValuesAnonymousClass(this, arr, valid);
}
- private class SingleDocValuesAnonymousInnerClassHelper : SingleDocValues
+ private class SingleDocValuesAnonymousClass : SingleDocValues
{
private readonly FieldCache.Singles arr;
private readonly IBits valid;
- public SingleDocValuesAnonymousInnerClassHelper(SingleFieldSource @this, FieldCache.Singles arr, IBits valid)
+ public SingleDocValuesAnonymousClass(SingleFieldSource @this, FieldCache.Singles arr, IBits valid)
: base(@this)
{
this.arr = arr;
diff --git a/src/Lucene.Net.Queries/Function/ValueSources/IfFunction.cs b/src/Lucene.Net.Queries/Function/ValueSources/IfFunction.cs
index af095f3..2c13413 100644
--- a/src/Lucene.Net.Queries/Function/ValueSources/IfFunction.cs
+++ b/src/Lucene.Net.Queries/Function/ValueSources/IfFunction.cs
@@ -45,16 +45,16 @@ namespace Lucene.Net.Queries.Function.ValueSources
FunctionValues trueVals = trueSource.GetValues(context, readerContext);
FunctionValues falseVals = falseSource.GetValues(context, readerContext);
- return new FunctionValuesAnonymousInnerClassHelper(ifVals, trueVals, falseVals);
+ return new FunctionValuesAnonymousClass(ifVals, trueVals, falseVals);
}
- private class FunctionValuesAnonymousInnerClassHelper : FunctionValues
+ private class FunctionValuesAnonymousClass : FunctionValues
{
private readonly FunctionValues ifVals;
private readonly FunctionValues trueVals;
private readonly FunctionValues falseVals;
- public FunctionValuesAnonymousInnerClassHelper(FunctionValues ifVals, FunctionValues trueVals, FunctionValues falseVals)
+ public FunctionValuesAnonymousClass(FunctionValues ifVals, FunctionValues trueVals, FunctionValues falseVals)
{
this.ifVals = ifVals;
this.trueVals = trueVals;
diff --git a/src/Lucene.Net.Queries/Function/ValueSources/IntFieldSource.cs b/src/Lucene.Net.Queries/Function/ValueSources/IntFieldSource.cs
index 24a3989..ac11ed0 100644
--- a/src/Lucene.Net.Queries/Function/ValueSources/IntFieldSource.cs
+++ b/src/Lucene.Net.Queries/Function/ValueSources/IntFieldSource.cs
@@ -57,17 +57,17 @@ namespace Lucene.Net.Queries.Function.ValueSources
FieldCache.Int32s arr = m_cache.GetInt32s(readerContext.AtomicReader, m_field, parser, true);
IBits valid = m_cache.GetDocsWithField(readerContext.AtomicReader, m_field);
- return new Int32DocValuesAnonymousInnerClassHelper(this, this, arr, valid);
+ return new Int32DocValuesAnonymousClass(this, this, arr, valid);
}
- private class Int32DocValuesAnonymousInnerClassHelper : Int32DocValues
+ private class Int32DocValuesAnonymousClass : Int32DocValues
{
private readonly Int32FieldSource outerInstance;
private readonly FieldCache.Int32s arr;
private readonly IBits valid;
- public Int32DocValuesAnonymousInnerClassHelper(Int32FieldSource outerInstance, Int32FieldSource @this, FieldCache.Int32s arr, IBits valid)
+ public Int32DocValuesAnonymousClass(Int32FieldSource outerInstance, Int32FieldSource @this, FieldCache.Int32s arr, IBits valid)
: base(@this)
{
this.outerInstance = outerInstance;
diff --git a/src/Lucene.Net.Queries/Function/ValueSources/JoinDocFreqValueSource.cs b/src/Lucene.Net.Queries/Function/ValueSources/JoinDocFreqValueSource.cs
index cc6288d..9054c0d 100644
--- a/src/Lucene.Net.Queries/Function/ValueSources/JoinDocFreqValueSource.cs
+++ b/src/Lucene.Net.Queries/Function/ValueSources/JoinDocFreqValueSource.cs
@@ -54,17 +54,17 @@ namespace Lucene.Net.Queries.Function.ValueSources
Terms t = MultiFields.GetTerms(top, m_qfield);
TermsEnum termsEnum = t == null ? TermsEnum.EMPTY : t.GetEnumerator();
- return new Int32DocValuesAnonymousInnerClassHelper(this, this, terms, termsEnum);
+ return new Int32DocValuesAnonymousClass(this, this, terms, termsEnum);
}
- private class Int32DocValuesAnonymousInnerClassHelper : Int32DocValues
+ private class Int32DocValuesAnonymousClass : Int32DocValues
{
private readonly JoinDocFreqValueSource outerInstance;
private readonly BinaryDocValues terms;
private readonly TermsEnum termsEnum;
- public Int32DocValuesAnonymousInnerClassHelper(JoinDocFreqValueSource outerInstance, JoinDocFreqValueSource @this, BinaryDocValues terms, TermsEnum termsEnum)
+ public Int32DocValuesAnonymousClass(JoinDocFreqValueSource outerInstance, JoinDocFreqValueSource @this, BinaryDocValues terms, TermsEnum termsEnum)
: base(@this)
{
this.outerInstance = outerInstance;
diff --git a/src/Lucene.Net.Queries/Function/ValueSources/LinearFloatFunction.cs b/src/Lucene.Net.Queries/Function/ValueSources/LinearFloatFunction.cs
index cc092fc..2a08aa6 100644
--- a/src/Lucene.Net.Queries/Function/ValueSources/LinearFloatFunction.cs
+++ b/src/Lucene.Net.Queries/Function/ValueSources/LinearFloatFunction.cs
@@ -53,15 +53,15 @@ namespace Lucene.Net.Queries.Function.ValueSources
public override FunctionValues GetValues(IDictionary context, AtomicReaderContext readerContext)
{
FunctionValues vals = m_source.GetValues(context, readerContext);
- return new SingleDocValuesAnonymousInnerClassHelper(this, this, vals);
+ return new SingleDocValuesAnonymousClass(this, this, vals);
}
- private class SingleDocValuesAnonymousInnerClassHelper : SingleDocValues
+ private class SingleDocValuesAnonymousClass : SingleDocValues
{
private readonly LinearSingleFunction outerInstance;
private readonly FunctionValues vals;
- public SingleDocValuesAnonymousInnerClassHelper(LinearSingleFunction outerInstance, LinearSingleFunction @this, FunctionValues vals)
+ public SingleDocValuesAnonymousClass(LinearSingleFunction outerInstance, LinearSingleFunction @this, FunctionValues vals)
: base(@this)
{
this.outerInstance = outerInstance;
diff --git a/src/Lucene.Net.Queries/Function/ValueSources/LiteralValueSource.cs b/src/Lucene.Net.Queries/Function/ValueSources/LiteralValueSource.cs
index 9de611d..2dd7b38 100644
--- a/src/Lucene.Net.Queries/Function/ValueSources/LiteralValueSource.cs
+++ b/src/Lucene.Net.Queries/Function/ValueSources/LiteralValueSource.cs
@@ -44,14 +44,14 @@ namespace Lucene.Net.Queries.Function.ValueSources
public override FunctionValues GetValues(IDictionary context, AtomicReaderContext readerContext)
{
- return new StrDocValuesAnonymousInnerClassHelper(this, this);
+ return new StrDocValuesAnonymousClass(this, this);
}
- private class StrDocValuesAnonymousInnerClassHelper : StrDocValues
+ private class StrDocValuesAnonymousClass : StrDocValues
{
private readonly LiteralValueSource outerInstance;
- public StrDocValuesAnonymousInnerClassHelper(LiteralValueSource outerInstance, LiteralValueSource @this)
+ public StrDocValuesAnonymousClass(LiteralValueSource outerInstance, LiteralValueSource @this)
: base(@this)
{
this.outerInstance = outerInstance;
diff --git a/src/Lucene.Net.Queries/Function/ValueSources/LongFieldSource.cs b/src/Lucene.Net.Queries/Function/ValueSources/LongFieldSource.cs
index b9882db..3d6653c 100644
--- a/src/Lucene.Net.Queries/Function/ValueSources/LongFieldSource.cs
+++ b/src/Lucene.Net.Queries/Function/ValueSources/LongFieldSource.cs
@@ -80,17 +80,17 @@ namespace Lucene.Net.Queries.Function.ValueSources
{
var arr = m_cache.GetInt64s(readerContext.AtomicReader, m_field, m_parser, true);
var valid = m_cache.GetDocsWithField(readerContext.AtomicReader, m_field);
- return new Int64DocValuesAnonymousInnerClassHelper(this, this, arr, valid);
+ return new Int64DocValuesAnonymousClass(this, this, arr, valid);
}
- private class Int64DocValuesAnonymousInnerClassHelper : Int64DocValues
+ private class Int64DocValuesAnonymousClass : Int64DocValues
{
private readonly Int64FieldSource outerInstance;
private readonly FieldCache.Int64s arr;
private readonly IBits valid;
- public Int64DocValuesAnonymousInnerClassHelper(Int64FieldSource outerInstance, Int64FieldSource @this, FieldCache.Int64s arr, IBits valid)
+ public Int64DocValuesAnonymousClass(Int64FieldSource outerInstance, Int64FieldSource @this, FieldCache.Int64s arr, IBits valid)
: base(@this)
{
this.outerInstance = outerInstance;
diff --git a/src/Lucene.Net.Queries/Function/ValueSources/MultiBoolFunction.cs b/src/Lucene.Net.Queries/Function/ValueSources/MultiBoolFunction.cs
index ff5a787..19bf4fe 100644
--- a/src/Lucene.Net.Queries/Function/ValueSources/MultiBoolFunction.cs
+++ b/src/Lucene.Net.Queries/Function/ValueSources/MultiBoolFunction.cs
@@ -51,16 +51,16 @@ namespace Lucene.Net.Queries.Function.ValueSources
vals[i++] = source.GetValues(context, readerContext);
}
- return new BoolDocValuesAnonymousInnerClassHelper(this, this, vals);
+ return new BoolDocValuesAnonymousClass(this, this, vals);
}
- private class BoolDocValuesAnonymousInnerClassHelper : BoolDocValues
+ private class BoolDocValuesAnonymousClass : BoolDocValues
{
private readonly MultiBoolFunction outerInstance;
private readonly FunctionValues[] vals;
- public BoolDocValuesAnonymousInnerClassHelper(MultiBoolFunction outerInstance, MultiBoolFunction @this, FunctionValues[] vals)
+ public BoolDocValuesAnonymousClass(MultiBoolFunction outerInstance, MultiBoolFunction @this, FunctionValues[] vals)
: base(@this)
{
this.outerInstance = outerInstance;
diff --git a/src/Lucene.Net.Queries/Function/ValueSources/MultiFloatFunction.cs b/src/Lucene.Net.Queries/Function/ValueSources/MultiFloatFunction.cs
index 156eda4..aaa0bbb 100644
--- a/src/Lucene.Net.Queries/Function/ValueSources/MultiFloatFunction.cs
+++ b/src/Lucene.Net.Queries/Function/ValueSources/MultiFloatFunction.cs
@@ -73,16 +73,16 @@ namespace Lucene.Net.Queries.Function.ValueSources
valsArr[i] = m_sources[i].GetValues(context, readerContext);
}
- return new SingleDocValuesAnonymousInnerClassHelper(this, this, valsArr);
+ return new SingleDocValuesAnonymousClass(this, this, valsArr);
}
- private class SingleDocValuesAnonymousInnerClassHelper : SingleDocValues
+ private class SingleDocValuesAnonymousClass : SingleDocValues
{
private readonly MultiSingleFunction outerInstance;
private readonly FunctionValues[] valsArr;
- public SingleDocValuesAnonymousInnerClassHelper(MultiSingleFunction outerInstance, MultiSingleFunction @this, FunctionValues[] valsArr)
+ public SingleDocValuesAnonymousClass(MultiSingleFunction outerInstance, MultiSingleFunction @this, FunctionValues[] valsArr)
: base(@this)
{
this.outerInstance = outerInstance;
diff --git a/src/Lucene.Net.Queries/Function/ValueSources/NormValueSource.cs b/src/Lucene.Net.Queries/Function/ValueSources/NormValueSource.cs
index 2e0dac1..d8e6deb 100644
--- a/src/Lucene.Net.Queries/Function/ValueSources/NormValueSource.cs
+++ b/src/Lucene.Net.Queries/Function/ValueSources/NormValueSource.cs
@@ -68,15 +68,15 @@ namespace Lucene.Net.Queries.Function.ValueSources
return new ConstDoubleDocValues(0.0, this);
}
- return new SingleDocValuesAnonymousInnerClassHelper(this, similarity, norms);
+ return new SingleDocValuesAnonymousClass(this, similarity, norms);
}
- private class SingleDocValuesAnonymousInnerClassHelper : SingleDocValues
+ private class SingleDocValuesAnonymousClass : SingleDocValues
{
private readonly TFIDFSimilarity similarity;
private readonly NumericDocValues norms;
- public SingleDocValuesAnonymousInnerClassHelper(NormValueSource @this, TFIDFSimilarity similarity, NumericDocValues norms)
+ public SingleDocValuesAnonymousClass(NormValueSource @this, TFIDFSimilarity similarity, NumericDocValues norms)
: base(@this)
{
this.similarity = similarity;
diff --git a/src/Lucene.Net.Queries/Function/ValueSources/OrdFieldSource.cs b/src/Lucene.Net.Queries/Function/ValueSources/OrdFieldSource.cs
index c43c7bd..8bdc8d9 100644
--- a/src/Lucene.Net.Queries/Function/ValueSources/OrdFieldSource.cs
+++ b/src/Lucene.Net.Queries/Function/ValueSources/OrdFieldSource.cs
@@ -66,15 +66,15 @@ namespace Lucene.Net.Queries.Function.ValueSources
IndexReader topReader = ReaderUtil.GetTopLevelContext(readerContext).Reader;
AtomicReader r = SlowCompositeReaderWrapper.Wrap(topReader);
SortedDocValues sindex = FieldCache.DEFAULT.GetTermsIndex(r, m_field);
- return new Int32DocValuesAnonymousInnerClassHelper(this, off, sindex);
+ return new Int32DocValuesAnonymousClass(this, off, sindex);
}
- private sealed class Int32DocValuesAnonymousInnerClassHelper : Int32DocValues
+ private sealed class Int32DocValuesAnonymousClass : Int32DocValues
{
private readonly int off;
private readonly SortedDocValues sindex;
- public Int32DocValuesAnonymousInnerClassHelper(OrdFieldSource @this, int off, SortedDocValues sindex)
+ public Int32DocValuesAnonymousClass(OrdFieldSource @this, int off, SortedDocValues sindex)
: base(@this)
{
this.off = off;
diff --git a/src/Lucene.Net.Queries/Function/ValueSources/RangeMapFloatFunction.cs b/src/Lucene.Net.Queries/Function/ValueSources/RangeMapFloatFunction.cs
index e38bd56..03389c6 100644
--- a/src/Lucene.Net.Queries/Function/ValueSources/RangeMapFloatFunction.cs
+++ b/src/Lucene.Net.Queries/Function/ValueSources/RangeMapFloatFunction.cs
@@ -63,10 +63,10 @@ namespace Lucene.Net.Queries.Function.ValueSources
FunctionValues vals = m_source.GetValues(context, readerContext);
FunctionValues targets = m_target.GetValues(context, readerContext);
FunctionValues defaults = (this.m_defaultVal == null) ? null : m_defaultVal.GetValues(context, readerContext);
- return new SingleDocValuesAnonymousInnerClassHelper(this, this, vals, targets, defaults);
+ return new SingleDocValuesAnonymousClass(this, this, vals, targets, defaults);
}
- private class SingleDocValuesAnonymousInnerClassHelper : SingleDocValues
+ private class SingleDocValuesAnonymousClass : SingleDocValues
{
private readonly RangeMapSingleFunction outerInstance;
@@ -74,7 +74,7 @@ namespace Lucene.Net.Queries.Function.ValueSources
private readonly FunctionValues targets;
private readonly FunctionValues defaults;
- public SingleDocValuesAnonymousInnerClassHelper(RangeMapSingleFunction outerInstance, RangeMapSingleFunction @this, FunctionValues vals, FunctionValues targets, FunctionValues defaults)
+ public SingleDocValuesAnonymousClass(RangeMapSingleFunction outerInstance, RangeMapSingleFunction @this, FunctionValues vals, FunctionValues targets, FunctionValues defaults)
: base(@this)
{
this.outerInstance = outerInstance;
diff --git a/src/Lucene.Net.Queries/Function/ValueSources/ReciprocalFloatFunction.cs b/src/Lucene.Net.Queries/Function/ValueSources/ReciprocalFloatFunction.cs
index 62aac92..e5bbb32 100644
--- a/src/Lucene.Net.Queries/Function/ValueSources/ReciprocalFloatFunction.cs
+++ b/src/Lucene.Net.Queries/Function/ValueSources/ReciprocalFloatFunction.cs
@@ -62,15 +62,15 @@ namespace Lucene.Net.Queries.Function.ValueSources
public override FunctionValues GetValues(IDictionary context, AtomicReaderContext readerContext)
{
var vals = m_source.GetValues(context, readerContext);
- return new SingleDocValuesAnonymousInnerClassHelper(this, this, vals);
+ return new SingleDocValuesAnonymousClass(this, this, vals);
}
- private class SingleDocValuesAnonymousInnerClassHelper : SingleDocValues
+ private class SingleDocValuesAnonymousClass : SingleDocValues
{
private readonly ReciprocalSingleFunction outerInstance;
private readonly FunctionValues vals;
- public SingleDocValuesAnonymousInnerClassHelper(ReciprocalSingleFunction outerInstance, ReciprocalSingleFunction @this, FunctionValues vals)
+ public SingleDocValuesAnonymousClass(ReciprocalSingleFunction outerInstance, ReciprocalSingleFunction @this, FunctionValues vals)
: base(@this)
{
this.outerInstance = outerInstance;
diff --git a/src/Lucene.Net.Queries/Function/ValueSources/ReverseOrdFieldSource.cs b/src/Lucene.Net.Queries/Function/ValueSources/ReverseOrdFieldSource.cs
index 3b54938..75c5f48 100644
--- a/src/Lucene.Net.Queries/Function/ValueSources/ReverseOrdFieldSource.cs
+++ b/src/Lucene.Net.Queries/Function/ValueSources/ReverseOrdFieldSource.cs
@@ -69,16 +69,16 @@ namespace Lucene.Net.Queries.Function.ValueSources
var sindex = FieldCache.DEFAULT.GetTermsIndex(r, field);
var end = sindex.ValueCount;
- return new Int32DocValuesAnonymousInnerClassHelper(this, off, sindex, end);
+ return new Int32DocValuesAnonymousClass(this, off, sindex, end);
}
- private class Int32DocValuesAnonymousInnerClassHelper : Int32DocValues
+ private class Int32DocValuesAnonymousClass : Int32DocValues
{
private readonly int off;
private readonly SortedDocValues sindex;
private readonly int end;
- public Int32DocValuesAnonymousInnerClassHelper(ReverseOrdFieldSource @this, int off, SortedDocValues sindex, int end)
+ public Int32DocValuesAnonymousClass(ReverseOrdFieldSource @this, int off, SortedDocValues sindex, int end)
: base(@this)
{
this.off = off;
diff --git a/src/Lucene.Net.Queries/Function/ValueSources/ScaleFloatFunction.cs b/src/Lucene.Net.Queries/Function/ValueSources/ScaleFloatFunction.cs
index e711b7a..e7d5584 100644
--- a/src/Lucene.Net.Queries/Function/ValueSources/ScaleFloatFunction.cs
+++ b/src/Lucene.Net.Queries/Function/ValueSources/ScaleFloatFunction.cs
@@ -117,10 +117,10 @@ namespace Lucene.Net.Queries.Function.ValueSources
float maxSource = scaleInfo.MaxVal;
var vals = m_source.GetValues(context, readerContext);
- return new SingleDocValuesAnonymousInnerClassHelper(this, this, scale, minSource, maxSource, vals);
+ return new SingleDocValuesAnonymousClass(this, this, scale, minSource, maxSource, vals);
}
- private class SingleDocValuesAnonymousInnerClassHelper : SingleDocValues
+ private class SingleDocValuesAnonymousClass : SingleDocValues
{
private readonly ScaleSingleFunction outerInstance;
@@ -129,7 +129,7 @@ namespace Lucene.Net.Queries.Function.ValueSources
private readonly float maxSource;
private readonly FunctionValues vals;
- public SingleDocValuesAnonymousInnerClassHelper(ScaleSingleFunction outerInstance, ScaleSingleFunction @this, float scale, float minSource, float maxSource, FunctionValues vals)
+ public SingleDocValuesAnonymousClass(ScaleSingleFunction outerInstance, ScaleSingleFunction @this, float scale, float minSource, float maxSource, FunctionValues vals)
: base(@this)
{
this.outerInstance = outerInstance;
diff --git a/src/Lucene.Net.Queries/Function/ValueSources/ShortFieldSource.cs b/src/Lucene.Net.Queries/Function/ValueSources/ShortFieldSource.cs
index 0bc6504..4131649 100644
--- a/src/Lucene.Net.Queries/Function/ValueSources/ShortFieldSource.cs
+++ b/src/Lucene.Net.Queries/Function/ValueSources/ShortFieldSource.cs
@@ -54,15 +54,15 @@ namespace Lucene.Net.Queries.Function.ValueSources
public override FunctionValues GetValues(IDictionary context, AtomicReaderContext readerContext)
{
var arr = m_cache.GetInt16s(readerContext.AtomicReader, m_field, parser, false);
- return new FunctionValuesAnonymousInnerClassHelper(this, arr);
+ return new FunctionValuesAnonymousClass(this, arr);
}
- private class FunctionValuesAnonymousInnerClassHelper : FunctionValues
+ private class FunctionValuesAnonymousClass : FunctionValues
{
private readonly Int16FieldSource outerInstance;
private readonly FieldCache.Int16s arr;
- public FunctionValuesAnonymousInnerClassHelper(Int16FieldSource outerInstance, FieldCache.Int16s arr)
+ public FunctionValuesAnonymousClass(Int16FieldSource outerInstance, FieldCache.Int16s arr)
{
this.outerInstance = outerInstance;
this.arr = arr;
diff --git a/src/Lucene.Net.Queries/Function/ValueSources/SimpleBoolFunction.cs b/src/Lucene.Net.Queries/Function/ValueSources/SimpleBoolFunction.cs
index 9f609c7..0fc2a94 100644
--- a/src/Lucene.Net.Queries/Function/ValueSources/SimpleBoolFunction.cs
+++ b/src/Lucene.Net.Queries/Function/ValueSources/SimpleBoolFunction.cs
@@ -45,16 +45,16 @@ namespace Lucene.Net.Queries.Function.ValueSources
public override FunctionValues GetValues(IDictionary context, AtomicReaderContext readerContext)
{
FunctionValues vals = m_source.GetValues(context, readerContext);
- return new BoolDocValuesAnonymousInnerClassHelper(this, this, vals);
+ return new BoolDocValuesAnonymousClass(this, this, vals);
}
- private class BoolDocValuesAnonymousInnerClassHelper : BoolDocValues
+ private class BoolDocValuesAnonymousClass : BoolDocValues
{
private readonly SimpleBoolFunction outerInstance;
private readonly FunctionValues vals;
- public BoolDocValuesAnonymousInnerClassHelper(SimpleBoolFunction outerInstance, SimpleBoolFunction @this, FunctionValues vals)
+ public BoolDocValuesAnonymousClass(SimpleBoolFunction outerInstance, SimpleBoolFunction @this, FunctionValues vals)
: base(@this)
{
this.outerInstance = outerInstance;
diff --git a/src/Lucene.Net.Queries/Function/ValueSources/SimpleFloatFunction.cs b/src/Lucene.Net.Queries/Function/ValueSources/SimpleFloatFunction.cs
index f30fb7f..bf0a48c 100644
--- a/src/Lucene.Net.Queries/Function/ValueSources/SimpleFloatFunction.cs
+++ b/src/Lucene.Net.Queries/Function/ValueSources/SimpleFloatFunction.cs
@@ -38,15 +38,15 @@ namespace Lucene.Net.Queries.Function.ValueSources
public override FunctionValues GetValues(IDictionary context, AtomicReaderContext readerContext)
{
FunctionValues vals = m_source.GetValues(context, readerContext);
- return new SingleDocValuesAnonymousInnerClassHelper(this, this, vals);
+ return new SingleDocValuesAnonymousClass(this, this, vals);
}
- private class SingleDocValuesAnonymousInnerClassHelper : SingleDocValues
+ private class SingleDocValuesAnonymousClass : SingleDocValues
{
private readonly SimpleSingleFunction outerInstance;
private readonly FunctionValues vals;
- public SingleDocValuesAnonymousInnerClassHelper(SimpleSingleFunction outerInstance, SimpleSingleFunction @this, FunctionValues vals)
+ public SingleDocValuesAnonymousClass(SimpleSingleFunction outerInstance, SimpleSingleFunction @this, FunctionValues vals)
: base(@this)
{
this.outerInstance = outerInstance;
diff --git a/src/Lucene.Net.Queries/Function/ValueSources/SumTotalTermFreqValueSource.cs b/src/Lucene.Net.Queries/Function/ValueSources/SumTotalTermFreqValueSource.cs
index b6d427f..60c72a2 100644
--- a/src/Lucene.Net.Queries/Function/ValueSources/SumTotalTermFreqValueSource.cs
+++ b/src/Lucene.Net.Queries/Function/ValueSources/SumTotalTermFreqValueSource.cs
@@ -78,14 +78,14 @@ namespace Lucene.Net.Queries.Function.ValueSources
}
}
long ttf = sumTotalTermFreq;
- context[this] = new Int64DocValuesAnonymousInnerClassHelper(this, ttf);
+ context[this] = new Int64DocValuesAnonymousClass(this, ttf);
}
- private class Int64DocValuesAnonymousInnerClassHelper : Int64DocValues
+ private class Int64DocValuesAnonymousClass : Int64DocValues
{
private readonly long ttf;
- public Int64DocValuesAnonymousInnerClassHelper(SumTotalTermFreqValueSource @this, long ttf)
+ public Int64DocValuesAnonymousClass(SumTotalTermFreqValueSource @this, long ttf)
: base(@this)
{
this.ttf = ttf;
diff --git a/src/Lucene.Net.Queries/Function/ValueSources/TFValueSource.cs b/src/Lucene.Net.Queries/Function/ValueSources/TFValueSource.cs
index 5b243d3..000403b 100644
--- a/src/Lucene.Net.Queries/Function/ValueSources/TFValueSource.cs
+++ b/src/Lucene.Net.Queries/Function/ValueSources/TFValueSource.cs
@@ -54,17 +54,17 @@ namespace Lucene.Net.Queries.Function.ValueSources
throw new NotSupportedException("requires a TFIDFSimilarity (such as DefaultSimilarity)");
}
- return new SingleDocValuesAnonymousInnerClassHelper(this, this, terms, similarity);
+ return new SingleDocValuesAnonymousClass(this, this, terms, similarity);
}
- private class SingleDocValuesAnonymousInnerClassHelper : SingleDocValues
+ private class SingleDocValuesAnonymousClass : SingleDocValues
{
private readonly TFValueSource outerInstance;
private readonly Terms terms;
private readonly TFIDFSimilarity similarity;
- public SingleDocValuesAnonymousInnerClassHelper(TFValueSource outerInstance, TFValueSource @this, Terms terms, TFIDFSimilarity similarity)
+ public SingleDocValuesAnonymousClass(TFValueSource outerInstance, TFValueSource @this, Terms terms, TFIDFSimilarity similarity)
: base(@this)
{
this.outerInstance = outerInstance;
@@ -101,12 +101,12 @@ namespace Lucene.Net.Queries.Function.ValueSources
if (docs == null)
{
- docs = new DocsEnumAnonymousInnerClassHelper();
+ docs = new DocsEnumAnonymousClass();
}
atDoc = -1;
}
- private class DocsEnumAnonymousInnerClassHelper : DocsEnum
+ private class DocsEnumAnonymousClass : DocsEnum
{
public override int Freq => 0;
diff --git a/src/Lucene.Net.Queries/Function/ValueSources/TermFreqValueSource.cs b/src/Lucene.Net.Queries/Function/ValueSources/TermFreqValueSource.cs
index 7985232..64fec78 100644
--- a/src/Lucene.Net.Queries/Function/ValueSources/TermFreqValueSource.cs
+++ b/src/Lucene.Net.Queries/Function/ValueSources/TermFreqValueSource.cs
@@ -46,16 +46,16 @@ namespace Lucene.Net.Queries.Function.ValueSources
Fields fields = readerContext.AtomicReader.Fields;
Terms terms = fields.GetTerms(m_indexedField);
- return new Int32DocValuesAnonymousInnerClassHelper(this, this, terms);
+ return new Int32DocValuesAnonymousClass(this, this, terms);
}
- private class Int32DocValuesAnonymousInnerClassHelper : Int32DocValues
+ private class Int32DocValuesAnonymousClass : Int32DocValues
{
private readonly TermFreqValueSource outerInstance;
private readonly Terms terms;
- public Int32DocValuesAnonymousInnerClassHelper(TermFreqValueSource outerInstance, TermFreqValueSource @this, Terms terms)
+ public Int32DocValuesAnonymousClass(TermFreqValueSource outerInstance, TermFreqValueSource @this, Terms terms)
: base(@this)
{
this.outerInstance = outerInstance;
@@ -91,12 +91,12 @@ namespace Lucene.Net.Queries.Function.ValueSources
if (docs == null)
{
- docs = new DocsEnumAnonymousInnerClassHelper();
+ docs = new DocsEnumAnonymousClass();
}
atDoc = -1;
}
- private class DocsEnumAnonymousInnerClassHelper : DocsEnum
+ private class DocsEnumAnonymousClass : DocsEnum
{
public override int Freq => 0;
diff --git a/src/Lucene.Net.Queries/Function/ValueSources/TotalTermFreqValueSource.cs b/src/Lucene.Net.Queries/Function/ValueSources/TotalTermFreqValueSource.cs
index c165255..38d6213 100644
--- a/src/Lucene.Net.Queries/Function/ValueSources/TotalTermFreqValueSource.cs
+++ b/src/Lucene.Net.Queries/Function/ValueSources/TotalTermFreqValueSource.cs
@@ -75,14 +75,14 @@ namespace Lucene.Net.Queries.Function.ValueSources
}
}
var ttf = totalTermFreq;
- context[this] = new Int64DocValuesAnonymousInnerClassHelper(this, ttf);
+ context[this] = new Int64DocValuesAnonymousClass(this, ttf);
}
- private class Int64DocValuesAnonymousInnerClassHelper : Int64DocValues
+ private class Int64DocValuesAnonymousClass : Int64DocValues
{
private readonly long ttf;
- public Int64DocValuesAnonymousInnerClassHelper(TotalTermFreqValueSource @this, long ttf)
+ public Int64DocValuesAnonymousClass(TotalTermFreqValueSource @this, long ttf)
: base(@this)
{
this.ttf = ttf;
diff --git a/src/Lucene.Net.Queries/Function/ValueSources/VectorValueSource.cs b/src/Lucene.Net.Queries/Function/ValueSources/VectorValueSource.cs
index ffa314b..3417447 100644
--- a/src/Lucene.Net.Queries/Function/ValueSources/VectorValueSource.cs
+++ b/src/Lucene.Net.Queries/Function/ValueSources/VectorValueSource.cs
@@ -53,7 +53,7 @@ namespace Lucene.Net.Queries.Function.ValueSources
{
var x = m_sources[0].GetValues(context, readerContext);
var y = m_sources[1].GetValues(context, readerContext);
- return new FunctionValuesAnonymousInnerClassHelper(this, x, y);
+ return new FunctionValuesAnonymousClass(this, x, y);
}
var valsArr = new FunctionValues[size];
@@ -62,17 +62,17 @@ namespace Lucene.Net.Queries.Function.ValueSources
valsArr[i] = m_sources[i].GetValues(context, readerContext);
}
- return new FunctionValuesAnonymousInnerClassHelper2(this, valsArr);
+ return new FunctionValuesAnonymousClass2(this, valsArr);
}
- private class FunctionValuesAnonymousInnerClassHelper : FunctionValues
+ private class FunctionValuesAnonymousClass : FunctionValues
{
private readonly VectorValueSource outerInstance;
private readonly FunctionValues x;
private readonly FunctionValues y;
- public FunctionValuesAnonymousInnerClassHelper(VectorValueSource outerInstance, FunctionValues x, FunctionValues y)
+ public FunctionValuesAnonymousClass(VectorValueSource outerInstance, FunctionValues x, FunctionValues y)
{
this.outerInstance = outerInstance;
this.x = x;
@@ -136,12 +136,12 @@ namespace Lucene.Net.Queries.Function.ValueSources
}
}
- private class FunctionValuesAnonymousInnerClassHelper2 : FunctionValues
+ private class FunctionValuesAnonymousClass2 : FunctionValues
{
private readonly VectorValueSource outerInstance;
private readonly FunctionValues[] valsArr;
- public FunctionValuesAnonymousInnerClassHelper2(VectorValueSource outerInstance, FunctionValues[] valsArr)
+ public FunctionValuesAnonymousClass2(VectorValueSource outerInstance, FunctionValues[] valsArr)
{
this.outerInstance = outerInstance;
this.valsArr = valsArr;
diff --git a/src/Lucene.Net.Queries/TermFilter.cs b/src/Lucene.Net.Queries/TermFilter.cs
index 2ae2605..9217e5f 100644
--- a/src/Lucene.Net.Queries/TermFilter.cs
+++ b/src/Lucene.Net.Queries/TermFilter.cs
@@ -59,15 +59,15 @@ namespace Lucene.Net.Queries
{
return null;
}
- return new DocIdSetAnonymousInnerClassHelper(acceptDocs, termsEnum);
+ return new DocIdSetAnonymousClass(acceptDocs, termsEnum);
}
- private class DocIdSetAnonymousInnerClassHelper : DocIdSet
+ private class DocIdSetAnonymousClass : DocIdSet
{
private readonly IBits acceptDocs;
private readonly TermsEnum termsEnum;
- public DocIdSetAnonymousInnerClassHelper(IBits acceptDocs, TermsEnum termsEnum)
+ public DocIdSetAnonymousClass(IBits acceptDocs, TermsEnum termsEnum)
{
this.acceptDocs = acceptDocs;
this.termsEnum = termsEnum;
diff --git a/src/Lucene.Net.Queries/TermsFilter.cs b/src/Lucene.Net.Queries/TermsFilter.cs
index e448d9e..960b894 100644
--- a/src/Lucene.Net.Queries/TermsFilter.cs
+++ b/src/Lucene.Net.Queries/TermsFilter.cs
@@ -55,13 +55,13 @@ namespace Lucene.Net.Queries
/// can contain duplicate terms and multiple fields.
/// </summary>
public TermsFilter(IList<Term> terms)
- : this(new FieldAndTermEnumAnonymousInnerClassHelper(terms), terms.Count)
+ : this(new FieldAndTermEnumAnonymousClass(terms), terms.Count)
{
}
- private class FieldAndTermEnumAnonymousInnerClassHelper : FieldAndTermEnum
+ private class FieldAndTermEnumAnonymousClass : FieldAndTermEnum
{
- public FieldAndTermEnumAnonymousInnerClassHelper(IList<Term> terms)
+ public FieldAndTermEnumAnonymousClass(IList<Term> terms)
{
if (terms.Count == 0)
{
@@ -93,13 +93,13 @@ namespace Lucene.Net.Queries
/// a single field.
/// </summary>
public TermsFilter(string field, IList<BytesRef> terms)
- : this(new FieldAndTermEnumAnonymousInnerClassHelper2(field, terms), terms.Count)
+ : this(new FieldAndTermEnumAnonymousClass2(field, terms), terms.Count)
{
}
- private class FieldAndTermEnumAnonymousInnerClassHelper2 : FieldAndTermEnum
+ private class FieldAndTermEnumAnonymousClass2 : FieldAndTermEnum
{
- public FieldAndTermEnumAnonymousInnerClassHelper2(string field, IList<BytesRef> terms)
+ public FieldAndTermEnumAnonymousClass2(string field, IList<BytesRef> terms)
: base(field)
{
if (terms.Count == 0)
diff --git a/src/Lucene.Net.Sandbox/Queries/SortedSetSortField.cs b/src/Lucene.Net.Sandbox/Queries/SortedSetSortField.cs
index 79b814c..7128c74 100644
--- a/src/Lucene.Net.Sandbox/Queries/SortedSetSortField.cs
+++ b/src/Lucene.Net.Sandbox/Queries/SortedSetSortField.cs
@@ -145,11 +145,11 @@ namespace Lucene.Net.Sandbox.Queries
}
}
- internal class TermOrdValComparerAnonymousHelper : FieldComparer.TermOrdValComparer
+ internal class TermOrdValComparerAnonymousClass : FieldComparer.TermOrdValComparer
{
private readonly SortedSetSortField outerInstance;
- public TermOrdValComparerAnonymousHelper(SortedSetSortField outerInstance, int numHits)
+ public TermOrdValComparerAnonymousClass(SortedSetSortField outerInstance, int numHits)
: base(numHits, outerInstance.Field, outerInstance.m_missingValue == STRING_LAST)
{
this.outerInstance = outerInstance;
@@ -199,7 +199,7 @@ namespace Lucene.Net.Sandbox.Queries
public override FieldComparer GetComparer(int numHits, int sortPos)
{
- return new TermOrdValComparerAnonymousHelper(this, numHits);
+ return new TermOrdValComparerAnonymousClass(this, numHits);
}
/// <summary>Wraps a <see cref="SortedSetDocValues"/> and returns the first ordinal (min)</summary>
diff --git a/src/Lucene.Net.Spatial/Prefix/ContainsPrefixTreeFilter.cs b/src/Lucene.Net.Spatial/Prefix/ContainsPrefixTreeFilter.cs
index de1da9c..11b55bf 100644
--- a/src/Lucene.Net.Spatial/Prefix/ContainsPrefixTreeFilter.cs
+++ b/src/Lucene.Net.Spatial/Prefix/ContainsPrefixTreeFilter.cs
@@ -305,17 +305,17 @@ namespace Lucene.Net.Spatial.Prefix
int size = d;
//sort them
Array.Sort(docs, 0, size);
- return new DocIdSetIteratorAnonymousHelper(size, docs);
+ return new DocIdSetIteratorAnonymousClass(size, docs);
}
- #region Nested Type: DocIdSetIteratorAnonymousHelper
+ #region Nested Type: DocIdSetIteratorAnonymousClass
- private sealed class DocIdSetIteratorAnonymousHelper : DocIdSetIterator
+ private sealed class DocIdSetIteratorAnonymousClass : DocIdSetIterator
{
private readonly int size;
private readonly int[] docs;
- public DocIdSetIteratorAnonymousHelper(int size, int[] docs)
+ public DocIdSetIteratorAnonymousClass(int size, int[] docs)
{
this.size = size;
this.docs = docs;
diff --git a/src/Lucene.Net.Spatial/Prefix/IntersectsPrefixTreeFilter.cs b/src/Lucene.Net.Spatial/Prefix/IntersectsPrefixTreeFilter.cs
index 49aebf0..f9672c3 100644
--- a/src/Lucene.Net.Spatial/Prefix/IntersectsPrefixTreeFilter.cs
+++ b/src/Lucene.Net.Spatial/Prefix/IntersectsPrefixTreeFilter.cs
@@ -62,16 +62,16 @@ namespace Lucene.Net.Spatial.Prefix
/// <exception cref="IOException"></exception>
public override DocIdSet GetDocIdSet(AtomicReaderContext context, IBits acceptDocs)
{
- return new VisitorTemplateAnonymousHelper(this, context, acceptDocs, hasIndexedLeaves).GetDocIdSet();
+ return new VisitorTemplateAnonymousClass(this, context, acceptDocs, hasIndexedLeaves).GetDocIdSet();
}
- #region Nested type: VisitorTemplateAnonymousHelper
+ #region Nested type: VisitorTemplateAnonymousClass
- private sealed class VisitorTemplateAnonymousHelper : VisitorTemplate
+ private sealed class VisitorTemplateAnonymousClass : VisitorTemplate
{
private FixedBitSet results;
- public VisitorTemplateAnonymousHelper(IntersectsPrefixTreeFilter outerInstance, AtomicReaderContext context, IBits acceptDocs, bool hasIndexedLeaves)
+ public VisitorTemplateAnonymousClass(IntersectsPrefixTreeFilter outerInstance, AtomicReaderContext context, IBits acceptDocs, bool hasIndexedLeaves)
: base(outerInstance, context, acceptDocs, hasIndexedLeaves)
{
}
diff --git a/src/Lucene.Net.Spatial/Prefix/WithinPrefixTreeFilter.cs b/src/Lucene.Net.Spatial/Prefix/WithinPrefixTreeFilter.cs
index b7da0be..c1ea3f6 100644
--- a/src/Lucene.Net.Spatial/Prefix/WithinPrefixTreeFilter.cs
+++ b/src/Lucene.Net.Spatial/Prefix/WithinPrefixTreeFilter.cs
@@ -140,18 +140,18 @@ namespace Lucene.Net.Spatial.Prefix
/// <exception cref="IOException"></exception>
public override DocIdSet GetDocIdSet(AtomicReaderContext context, IBits acceptDocs)
{
- return new VisitorTemplateAnonymousHelper(this, context, acceptDocs, true).GetDocIdSet();
+ return new VisitorTemplateAnonymousClass(this, context, acceptDocs, true).GetDocIdSet();
}
- #region Nested type: VisitorTemplateAnonymousHelper
+ #region Nested type: VisitorTemplateAnonymousClass
- private sealed class VisitorTemplateAnonymousHelper : VisitorTemplate
+ private sealed class VisitorTemplateAnonymousClass : VisitorTemplate
{
private FixedBitSet inside;
private FixedBitSet outside;
private SpatialRelation visitRelation;
- public VisitorTemplateAnonymousHelper(WithinPrefixTreeFilter outerInstance, AtomicReaderContext context,
+ public VisitorTemplateAnonymousClass(WithinPrefixTreeFilter outerInstance, AtomicReaderContext context,
IBits acceptDocs, bool hasIndexedLeaves)
: base(outerInstance, context, acceptDocs, hasIndexedLeaves)
{
diff --git a/src/Lucene.Net.Spatial/Serialized/SerializedDVStrategy.cs b/src/Lucene.Net.Spatial/Serialized/SerializedDVStrategy.cs
index 184ce53..f6dba8c 100644
--- a/src/Lucene.Net.Spatial/Serialized/SerializedDVStrategy.cs
+++ b/src/Lucene.Net.Spatial/Serialized/SerializedDVStrategy.cs
@@ -67,7 +67,7 @@ namespace Lucene.Net.Spatial.Serialized
m_ctx.BinaryCodec.WriteShape(new BinaryWriter(byteStream), shape);
//this is a hack to avoid redundant byte array copying by byteStream.toByteArray()
- byteStream.WriteTo(new OutputStreamAnonymousHelper(bytesRef));
+ byteStream.WriteTo(new OutputStreamAnonymousClass(bytesRef));
}
catch (IOException e)
{
@@ -77,11 +77,11 @@ namespace Lucene.Net.Spatial.Serialized
return new Field[] { new BinaryDocValuesField(FieldName, bytesRef) };
}
- internal class OutputStreamAnonymousHelper : MemoryStream
+ internal class OutputStreamAnonymousClass : MemoryStream
{
private readonly BytesRef bytesRef;
- public OutputStreamAnonymousHelper(BytesRef bytesRef)
+ public OutputStreamAnonymousClass(BytesRef bytesRef)
{
this.bytesRef = bytesRef;
}
@@ -144,16 +144,16 @@ namespace Lucene.Net.Spatial.Serialized
public override DocIdSet GetDocIdSet(AtomicReaderContext context, IBits acceptDocs)
{
- return new DocIdSetAnonymousHelper(this, context, acceptDocs);
+ return new DocIdSetAnonymousClass(this, context, acceptDocs);
}
- internal class DocIdSetAnonymousHelper : DocIdSet
+ internal class DocIdSetAnonymousClass : DocIdSet
{
private readonly PredicateValueSourceFilter outerInstance;
private readonly AtomicReaderContext context;
private readonly IBits acceptDocs;
- public DocIdSetAnonymousHelper(PredicateValueSourceFilter outerInstance, AtomicReaderContext context, IBits acceptDocs)
+ public DocIdSetAnonymousClass(PredicateValueSourceFilter outerInstance, AtomicReaderContext context, IBits acceptDocs)
{
this.outerInstance = outerInstance;
this.context = context;
@@ -174,17 +174,17 @@ namespace Lucene.Net.Spatial.Serialized
//null Map context -- we simply don't have one. That's ok.
FunctionValues predFuncValues = outerInstance.predicateValueSource.GetValues(null, context);
- return new BitsAnonymousHelper(predFuncValues, context, acceptDocs);
+ return new BitsAnonymousClass(predFuncValues, context, acceptDocs);
}
}
- internal class BitsAnonymousHelper : IBits
+ internal class BitsAnonymousClass : IBits
{
private readonly FunctionValues predFuncValues;
private readonly AtomicReaderContext context;
private readonly IBits acceptDocs;
- public BitsAnonymousHelper(FunctionValues predFuncValues, AtomicReaderContext context, IBits acceptDocs)
+ public BitsAnonymousClass(FunctionValues predFuncValues, AtomicReaderContext context, IBits acceptDocs)
{
this.predFuncValues = predFuncValues;
this.context = context;
@@ -240,15 +240,15 @@ namespace Lucene.Net.Spatial.Serialized
{
BinaryDocValues docValues = readerContext.AtomicReader.GetBinaryDocValues(fieldName);
- return new FuctionValuesAnonymousHelper(this, docValues);
+ return new FuctionValuesAnonymousClass(this, docValues);
}
- internal class FuctionValuesAnonymousHelper : FunctionValues
+ internal class FuctionValuesAnonymousClass : FunctionValues
{
private readonly ShapeDocValueSource outerInstance;
private readonly BinaryDocValues docValues;
- public FuctionValuesAnonymousHelper(ShapeDocValueSource outerInstance, BinaryDocValues docValues)
+ public FuctionValuesAnonymousClass(ShapeDocValueSource outerInstance, BinaryDocValues docValues)
{
this.outerInstance = outerInstance;
this.docValues = docValues;
diff --git a/src/Lucene.Net.Spatial/Util/DistanceToShapeValueSource.cs b/src/Lucene.Net.Spatial/Util/DistanceToShapeValueSource.cs
index 247e657..d546db6 100644
--- a/src/Lucene.Net.Spatial/Util/DistanceToShapeValueSource.cs
+++ b/src/Lucene.Net.Spatial/Util/DistanceToShapeValueSource.cs
@@ -69,15 +69,15 @@ namespace Lucene.Net.Spatial.Util
{
FunctionValues shapeValues = shapeValueSource.GetValues(context, readerContext);
- return new DoubleDocValuesAnonymousHelper(this, shapeValues);
+ return new DoubleDocValuesAnonymousClass(this, shapeValues);
}
- internal class DoubleDocValuesAnonymousHelper : DoubleDocValues
+ internal class DoubleDocValuesAnonymousClass : DoubleDocValues
{
private readonly DistanceToShapeValueSource outerInstance;
private readonly FunctionValues shapeValues;
- public DoubleDocValuesAnonymousHelper(DistanceToShapeValueSource outerInstance, FunctionValues shapeValues)
+ public DoubleDocValuesAnonymousClass(DistanceToShapeValueSource outerInstance, FunctionValues shapeValues)
: base(outerInstance)
{
this.outerInstance = outerInstance;
diff --git a/src/Lucene.Net.Spatial/Util/ShapePredicateValueSource.cs b/src/Lucene.Net.Spatial/Util/ShapePredicateValueSource.cs
index 179aac5..80e904c 100644
--- a/src/Lucene.Net.Spatial/Util/ShapePredicateValueSource.cs
+++ b/src/Lucene.Net.Spatial/Util/ShapePredicateValueSource.cs
@@ -69,15 +69,15 @@ namespace Lucene.Net.Spatial.Util
{
FunctionValues shapeValues = shapeValuesource.GetValues(context, readerContext);
- return new BoolDocValuesAnonymousHelper(this, shapeValues);
+ return new BoolDocValuesAnonymousClass(this, shapeValues);
}
- internal class BoolDocValuesAnonymousHelper : BoolDocValues
+ internal class BoolDocValuesAnonymousClass : BoolDocValues
{
private readonly ShapePredicateValueSource outerInstance;
private readonly FunctionValues shapeValues;
- public BoolDocValuesAnonymousHelper(ShapePredicateValueSource outerInstance, FunctionValues shapeValues)
+ public BoolDocValuesAnonymousClass(ShapePredicateValueSource outerInstance, FunctionValues shapeValues)
: base(outerInstance)
{
this.outerInstance = outerInstance;
diff --git a/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingInfixSuggester.cs b/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingInfixSuggester.cs
index eff3a8f..ef411a7 100644
--- a/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingInfixSuggester.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingInfixSuggester.cs
@@ -288,13 +288,13 @@ namespace Lucene.Net.Search.Suggest.Analyzing
}
private Analyzer GetGramAnalyzer()
- => new AnalyzerWrapperAnonymousInnerClassHelper(this, Analyzer.PER_FIELD_REUSE_STRATEGY);
+ => new AnalyzerWrapperAnonymousClass(this, Analyzer.PER_FIELD_REUSE_STRATEGY);
- private class AnalyzerWrapperAnonymousInnerClassHelper : AnalyzerWrapper
+ private class AnalyzerWrapperAnonymousClass : AnalyzerWrapper
{
private readonly AnalyzingInfixSuggester outerInstance;
- public AnalyzerWrapperAnonymousInnerClassHelper(AnalyzingInfixSuggester outerInstance, ReuseStrategy reuseStrategy)
+ public AnalyzerWrapperAnonymousClass(AnalyzingInfixSuggester outerInstance, ReuseStrategy reuseStrategy)
: base(reuseStrategy)
{
this.outerInstance = outerInstance;
diff --git a/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingSuggester.cs b/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingSuggester.cs
index b4e44cc..01775fd 100644
--- a/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingSuggester.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingSuggester.cs
@@ -835,7 +835,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
}
Util.Fst.Util.TopNSearcher<PairOutputs<long?, BytesRef>.Pair> searcher2;
- searcher2 = new TopNSearcherAnonymousInnerClassHelper(this, fst, num - results.Count,
+ searcher2 = new TopNSearcherAnonymousClass(this, fst, num - results.Count,
num * maxAnalyzedPathsForOneInput, weightComparer, utf8Key, results);
prefixPaths = GetFullPrefixPaths(prefixPaths, lookupAutomaton, fst);
@@ -875,14 +875,14 @@ namespace Lucene.Net.Search.Suggest.Analyzing
}
}
- private class TopNSearcherAnonymousInnerClassHelper : Util.Fst.Util.TopNSearcher<PairOutputs<long?, BytesRef>.Pair>
+ private class TopNSearcherAnonymousClass : Util.Fst.Util.TopNSearcher<PairOutputs<long?, BytesRef>.Pair>
{
private readonly AnalyzingSuggester outerInstance;
private readonly BytesRef utf8Key;
private readonly IList<LookupResult> results;
- public TopNSearcherAnonymousInnerClassHelper(
+ public TopNSearcherAnonymousClass(
AnalyzingSuggester outerInstance,
FST<PairOutputs<long?, BytesRef>.Pair> fst,
int topN,
diff --git a/src/Lucene.Net.Suggest/Suggest/Analyzing/FreeTextSuggester.cs b/src/Lucene.Net.Suggest/Suggest/Analyzing/FreeTextSuggester.cs
index d7d2594..8f30e41 100644
--- a/src/Lucene.Net.Suggest/Suggest/Analyzing/FreeTextSuggester.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Analyzing/FreeTextSuggester.cs
@@ -258,16 +258,16 @@ namespace Lucene.Net.Search.Suggest.Analyzing
{
// TODO: use ShingleAnalyzerWrapper?
// Tack on ShingleFilter to the end, to generate token ngrams:
- return new AnalyzerWrapperAnonymousInnerClassHelper(this, other.Strategy, other);
+ return new AnalyzerWrapperAnonymousClass(this, other.Strategy, other);
}
}
- private class AnalyzerWrapperAnonymousInnerClassHelper : AnalyzerWrapper
+ private class AnalyzerWrapperAnonymousClass : AnalyzerWrapper
{
private readonly FreeTextSuggester outerInstance;
private readonly Analyzer other;
- public AnalyzerWrapperAnonymousInnerClassHelper(FreeTextSuggester outerInstance, ReuseStrategy reuseStrategy, Analyzer other)
+ public AnalyzerWrapperAnonymousClass(FreeTextSuggester outerInstance, ReuseStrategy reuseStrategy, Analyzer other)
: base(reuseStrategy)
{
this.outerInstance = outerInstance;
@@ -712,7 +712,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
// Must do num+seen.size() for queue depth because we may
// reject up to seen.size() paths in acceptResult():
- Util.Fst.Util.TopNSearcher<long?> searcher = new TopNSearcherAnonymousInnerClassHelper(this, fst, num, num + seen.Count, weightComparer, seen, finalLastToken);
+ Util.Fst.Util.TopNSearcher<long?> searcher = new TopNSearcherAnonymousClass(this, fst, num, num + seen.Count, weightComparer, seen, finalLastToken);
// since this search is initialized with a single start node
// it is okay to start with an empty input path here
@@ -802,14 +802,14 @@ namespace Lucene.Net.Search.Suggest.Analyzing
}
}
- private class TopNSearcherAnonymousInnerClassHelper : Util.Fst.Util.TopNSearcher<long?>
+ private class TopNSearcherAnonymousClass : Util.Fst.Util.TopNSearcher<long?>
{
private readonly FreeTextSuggester outerInstance;
private readonly ISet<BytesRef> seen;
private readonly BytesRef finalLastToken;
- public TopNSearcherAnonymousInnerClassHelper(
+ public TopNSearcherAnonymousClass(
FreeTextSuggester outerInstance,
FST<long?> fst,
int num,
diff --git a/src/Lucene.Net.TestFramework/Analysis/CollationTestBase.cs b/src/Lucene.Net.TestFramework/Analysis/CollationTestBase.cs
index cabf204..83dd51a 100644
--- a/src/Lucene.Net.TestFramework/Analysis/CollationTestBase.cs
+++ b/src/Lucene.Net.TestFramework/Analysis/CollationTestBase.cs
@@ -288,7 +288,7 @@ namespace Lucene.Net.Analysis
ThreadJob[] threads = new ThreadJob[numThreads];
for (int i = 0; i < numThreads; i++)
{
- threads[i] = new ThreadAnonymousInnerClassHelper(analyzer, map);
+ threads[i] = new ThreadAnonymousClass(analyzer, map);
}
for (int i = 0; i < numThreads; i++)
{
@@ -300,12 +300,12 @@ namespace Lucene.Net.Analysis
}
}
- private class ThreadAnonymousInnerClassHelper : ThreadJob
+ private class ThreadAnonymousClass : ThreadJob
{
private readonly Analyzer analyzer;
private readonly IDictionary<string, BytesRef> map;
- public ThreadAnonymousInnerClassHelper(Analyzer analyzer, IDictionary<string, BytesRef> map)
+ public ThreadAnonymousClass(Analyzer analyzer, IDictionary<string, BytesRef> map)
{
this.analyzer = analyzer;
this.map = map;
diff --git a/src/Lucene.Net.TestFramework/Analysis/LookaheadTokenFilter.cs b/src/Lucene.Net.TestFramework/Analysis/LookaheadTokenFilter.cs
index c2ab2a8..d5d0fb7 100644
--- a/src/Lucene.Net.TestFramework/Analysis/LookaheadTokenFilter.cs
+++ b/src/Lucene.Net.TestFramework/Analysis/LookaheadTokenFilter.cs
@@ -123,7 +123,7 @@ namespace Lucene.Net.Analysis
protected internal LookaheadTokenFilter(TokenStream input)
: base(input)
{
- m_positions = new RollingBufferAnonymousInnerClassHelper(this);
+ m_positions = new RollingBufferAnonymousClass(this);
m_posIncAtt = AddAttribute<IPositionIncrementAttribute>();
m_posLenAtt = AddAttribute<IPositionLengthAttribute>();
m_offsetAtt = AddAttribute<IOffsetAttribute>();
@@ -160,11 +160,11 @@ namespace Lucene.Net.Analysis
protected readonly RollingBuffer<T> m_positions;
- private class RollingBufferAnonymousInnerClassHelper : RollingBuffer<T>
+ private class RollingBufferAnonymousClass : RollingBuffer<T>
{
private readonly LookaheadTokenFilter<T> outerInstance;
- public RollingBufferAnonymousInnerClassHelper(LookaheadTokenFilter<T> outerInstance)
+ public RollingBufferAnonymousClass(LookaheadTokenFilter<T> outerInstance)
: base(outerInstance.NewPosition)
{
this.outerInstance = outerInstance;
diff --git a/src/Lucene.Net.TestFramework/Codecs/Compressing/Dummy/DummyCompressingCodec.cs b/src/Lucene.Net.TestFramework/Codecs/Compressing/Dummy/DummyCompressingCodec.cs
index f1eef1b..b219a43 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Compressing/Dummy/DummyCompressingCodec.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Compressing/Dummy/DummyCompressingCodec.cs
@@ -28,11 +28,11 @@ namespace Lucene.Net.Codecs.Compressing.Dummy
[CodecName("DummyCompressingStoredFields")]
public class DummyCompressingCodec : CompressingCodec
{
- public static readonly CompressionMode DUMMY = new CompressionModeAnonymousInnerClassHelper();
+ public static readonly CompressionMode DUMMY = new CompressionModeAnonymousClass();
- private class CompressionModeAnonymousInnerClassHelper : CompressionMode
+ private class CompressionModeAnonymousClass : CompressionMode
{
- public CompressionModeAnonymousInnerClassHelper()
+ public CompressionModeAnonymousClass()
{ }
public override Compressor NewCompressor()
@@ -51,9 +51,9 @@ namespace Lucene.Net.Codecs.Compressing.Dummy
}
}
- private static readonly Decompressor DUMMY_DECOMPRESSOR = new DecompressorAnonymousInnerClassHelper();
+ private static readonly Decompressor DUMMY_DECOMPRESSOR = new DecompressorAnonymousClass();
- private class DecompressorAnonymousInnerClassHelper : Decompressor
+ private class DecompressorAnonymousClass : Decompressor
{
public override void Decompress(DataInput @in, int originalLength, int offset, int length, BytesRef bytes)
{
@@ -73,9 +73,9 @@ namespace Lucene.Net.Codecs.Compressing.Dummy
}
}
- private static readonly Compressor DUMMY_COMPRESSOR = new CompressorAnonymousInnerClassHelper();
+ private static readonly Compressor DUMMY_COMPRESSOR = new CompressorAnonymousClass();
- private class CompressorAnonymousInnerClassHelper : Compressor
+ private class CompressorAnonymousClass : Compressor
{
public override void Compress(byte[] bytes, int off, int len, DataOutput @out)
{
diff --git a/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWPostingsFormat.cs b/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWPostingsFormat.cs
index 26bce39..64a3b3c 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWPostingsFormat.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWPostingsFormat.cs
@@ -46,12 +46,12 @@ namespace Lucene.Net.Codecs.Lucene3x
// Whenever IW opens readers, eg for merging, we have to
// keep terms order in UTF16:
- return new Lucene3xFieldsAnonymousInnerClassHelper(state.Directory, state.FieldInfos, state.SegmentInfo, state.Context, state.TermsIndexDivisor);
+ return new Lucene3xFieldsAnonymousClass(state.Directory, state.FieldInfos, state.SegmentInfo, state.Context, state.TermsIndexDivisor);
}
- private class Lucene3xFieldsAnonymousInnerClassHelper : Lucene3xFields
+ private class Lucene3xFieldsAnonymousClass : Lucene3xFields
{
- public Lucene3xFieldsAnonymousInnerClassHelper(Store.Directory directory, FieldInfos fieldInfos, SegmentInfo segmentInfo, Store.IOContext context, int termsIndexDivisor)
+ public Lucene3xFieldsAnonymousClass(Store.Directory directory, FieldInfos fieldInfos, SegmentInfo segmentInfo, Store.IOContext context, int termsIndexDivisor)
: base(directory, fieldInfos, segmentInfo, context, termsIndexDivisor)
{
}
diff --git a/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWTermVectorsFormat.cs b/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWTermVectorsFormat.cs
index 82ed18a..1e5e6d1 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWTermVectorsFormat.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Lucene3x/PreFlexRWTermVectorsFormat.cs
@@ -32,12 +32,12 @@ namespace Lucene.Net.Codecs.Lucene3x
public override TermVectorsReader VectorsReader(Directory directory, SegmentInfo segmentInfo, FieldInfos fieldInfos, IOContext context)
{
- return new Lucene3xTermVectorsReaderAnonymousInnerClassHelper(directory, segmentInfo, fieldInfos, context);
+ return new Lucene3xTermVectorsReaderAnonymousClass(directory, segmentInfo, fieldInfos, context);
}
- private class Lucene3xTermVectorsReaderAnonymousInnerClassHelper : Lucene3xTermVectorsReader
+ private class Lucene3xTermVectorsReaderAnonymousClass : Lucene3xTermVectorsReader
{
- public Lucene3xTermVectorsReaderAnonymousInnerClassHelper(Directory directory, SegmentInfo segmentInfo, FieldInfos fieldInfos, IOContext context)
+ public Lucene3xTermVectorsReaderAnonymousClass(Directory directory, SegmentInfo segmentInfo, FieldInfos fieldInfos, IOContext context)
: base(directory, segmentInfo, fieldInfos, context)
{
}
diff --git a/src/Lucene.Net.TestFramework/Codecs/Lucene40/Lucene40RWCodec.cs b/src/Lucene.Net.TestFramework/Codecs/Lucene40/Lucene40RWCodec.cs
index 99563cd..8255e0b 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Lucene40/Lucene40RWCodec.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Lucene40/Lucene40RWCodec.cs
@@ -24,9 +24,9 @@ namespace Lucene.Net.Codecs.Lucene40
#pragma warning disable 612, 618
public sealed class Lucene40RWCodec : Lucene40Codec
{
- private readonly FieldInfosFormat fieldInfos = new Lucene40FieldInfosFormatAnonymousInnerClassHelper();
+ private readonly FieldInfosFormat fieldInfos = new Lucene40FieldInfosFormatAnonymousClass();
- private class Lucene40FieldInfosFormatAnonymousInnerClassHelper : Lucene40FieldInfosFormat
+ private class Lucene40FieldInfosFormatAnonymousClass : Lucene40FieldInfosFormat
{
public override FieldInfosWriter FieldInfosWriter
{
diff --git a/src/Lucene.Net.TestFramework/Codecs/Lucene41/Lucene41RWCodec.cs b/src/Lucene.Net.TestFramework/Codecs/Lucene41/Lucene41RWCodec.cs
index 94b7886..a29d283 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Lucene41/Lucene41RWCodec.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Lucene41/Lucene41RWCodec.cs
@@ -27,9 +27,9 @@ namespace Lucene.Net.Codecs.Lucene41
public class Lucene41RWCodec : Lucene41Codec
{
private readonly StoredFieldsFormat fieldsFormat = new Lucene41StoredFieldsFormat();
- private readonly FieldInfosFormat fieldInfos = new Lucene40FieldInfosFormatAnonymousInnerClassHelper();
+ private readonly FieldInfosFormat fieldInfos = new Lucene40FieldInfosFormatAnonymousClass();
- private class Lucene40FieldInfosFormatAnonymousInnerClassHelper : Lucene40FieldInfosFormat
+ private class Lucene40FieldInfosFormatAnonymousClass : Lucene40FieldInfosFormat
{
public override FieldInfosWriter FieldInfosWriter
{
diff --git a/src/Lucene.Net.TestFramework/Codecs/Lucene42/Lucene42DocValuesConsumer.cs b/src/Lucene.Net.TestFramework/Codecs/Lucene42/Lucene42DocValuesConsumer.cs
index a30c4c4..c0b3d9c 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Lucene42/Lucene42DocValuesConsumer.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Lucene42/Lucene42DocValuesConsumer.cs
@@ -345,18 +345,18 @@ namespace Lucene.Net.Codecs.Lucene42
public override void AddSortedSetField(FieldInfo field, IEnumerable<BytesRef> values, IEnumerable<long?> docToOrdCount, IEnumerable<long?> ords)
{
// write the ordinals as a binary field
- AddBinaryField(field, new IterableAnonymousInnerClassHelper(docToOrdCount, ords));
+ AddBinaryField(field, new IterableAnonymousClass(docToOrdCount, ords));
// write the values as FST
WriteFST(field, values);
}
- private class IterableAnonymousInnerClassHelper : IEnumerable<BytesRef>
+ private class IterableAnonymousClass : IEnumerable<BytesRef>
{
private readonly IEnumerable<long?> docToOrdCount;
private readonly IEnumerable<long?> ords;
- public IterableAnonymousInnerClassHelper(IEnumerable<long?> docToOrdCount, IEnumerable<long?> ords)
+ public IterableAnonymousClass(IEnumerable<long?> docToOrdCount, IEnumerable<long?> ords)
{
this.docToOrdCount = docToOrdCount;
this.ords = ords;
diff --git a/src/Lucene.Net.TestFramework/Codecs/Lucene42/Lucene42RWCodec.cs b/src/Lucene.Net.TestFramework/Codecs/Lucene42/Lucene42RWCodec.cs
index 390edb6..36b1ecc 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Lucene42/Lucene42RWCodec.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Lucene42/Lucene42RWCodec.cs
@@ -28,9 +28,9 @@ namespace Lucene.Net.Codecs.Lucene42
private readonly DocValuesFormat dv = new Lucene42RWDocValuesFormat();
private readonly NormsFormat norms = new Lucene42NormsFormat();
- private readonly FieldInfosFormat fieldInfosFormat = new Lucene42FieldInfosFormatAnonymousInnerClassHelper();
+ private readonly FieldInfosFormat fieldInfosFormat = new Lucene42FieldInfosFormatAnonymousClass();
- private class Lucene42FieldInfosFormatAnonymousInnerClassHelper : Lucene42FieldInfosFormat
+ private class Lucene42FieldInfosFormatAnonymousClass : Lucene42FieldInfosFormat
{
public override FieldInfosWriter FieldInfosWriter
{
diff --git a/src/Lucene.Net.TestFramework/Codecs/Lucene45/Lucene45RWCodec.cs b/src/Lucene.Net.TestFramework/Codecs/Lucene45/Lucene45RWCodec.cs
index 0850b5b..db0cc6c 100644
--- a/src/Lucene.Net.TestFramework/Codecs/Lucene45/Lucene45RWCodec.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/Lucene45/Lucene45RWCodec.cs
@@ -26,9 +26,9 @@ namespace Lucene.Net.Codecs.Lucene45
#pragma warning disable 612, 618
public class Lucene45RWCodec : Lucene45Codec
{
- private readonly FieldInfosFormat fieldInfosFormat = new Lucene42FieldInfosFormatAnonymousInnerClassHelper();
+ private readonly FieldInfosFormat fieldInfosFormat = new Lucene42FieldInfosFormatAnonymousClass();
- private class Lucene42FieldInfosFormatAnonymousInnerClassHelper : Lucene42FieldInfosFormat
+ private class Lucene42FieldInfosFormatAnonymousClass : Lucene42FieldInfosFormat
{
public override FieldInfosWriter FieldInfosWriter
{
diff --git a/src/Lucene.Net.TestFramework/Codecs/MissingOrdRemapper.cs b/src/Lucene.Net.TestFramework/Codecs/MissingOrdRemapper.cs
index e7da523..cf0e6c3 100644
--- a/src/Lucene.Net.TestFramework/Codecs/MissingOrdRemapper.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/MissingOrdRemapper.cs
@@ -32,21 +32,21 @@ namespace Lucene.Net.Codecs
/// Insert an empty byte[] to the front of this enumerable.</summary>
public static IEnumerable<BytesRef> InsertEmptyValue(IEnumerable<BytesRef> iterable)
{
- return new IterableAnonymousInnerClassHelper(iterable);
+ return new IterableAnonymousClass(iterable);
}
- private class IterableAnonymousInnerClassHelper : IEnumerable<BytesRef>
+ private class IterableAnonymousClass : IEnumerable<BytesRef>
{
private readonly IEnumerable<BytesRef> iterable;
- public IterableAnonymousInnerClassHelper(IEnumerable<BytesRef> iterable)
+ public IterableAnonymousClass(IEnumerable<BytesRef> iterable)
{
this.iterable = iterable;
}
public IEnumerator<BytesRef> GetEnumerator()
{
- return new IteratorAnonymousInnerClassHelper(this);
+ return new IteratorAnonymousClass(this);
}
IEnumerator IEnumerable.GetEnumerator()
@@ -54,9 +54,9 @@ namespace Lucene.Net.Codecs
return GetEnumerator();
}
- private class IteratorAnonymousInnerClassHelper : IEnumerator<BytesRef>
+ private class IteratorAnonymousClass : IEnumerator<BytesRef>
{
- public IteratorAnonymousInnerClassHelper(IterableAnonymousInnerClassHelper outerInstance)
+ public IteratorAnonymousClass(IterableAnonymousClass outerInstance)
{
seenEmpty = false;
@in = outerInstance.iterable.GetEnumerator();
@@ -100,29 +100,29 @@ namespace Lucene.Net.Codecs
/// Remaps ord -1 to ord 0 on this enumerable. </summary>
public static IEnumerable<long?> MapMissingToOrd0(IEnumerable<long?> iterable)
{
- return new IterableAnonymousInnerClassHelper2(iterable);
+ return new IterableAnonymousClass2(iterable);
}
- private class IterableAnonymousInnerClassHelper2 : IEnumerable<long?>
+ private class IterableAnonymousClass2 : IEnumerable<long?>
{
private readonly IEnumerable<long?> iterable;
- public IterableAnonymousInnerClassHelper2(IEnumerable<long?> iterable)
+ public IterableAnonymousClass2(IEnumerable<long?> iterable)
{
this.iterable = iterable;
}
public IEnumerator<long?> GetEnumerator()
{
- return new IteratorAnonymousInnerClassHelper2(this);
+ return new IteratorAnonymousClass2(this);
}
IEnumerator IEnumerable.GetEnumerator()
=> GetEnumerator();
- private class IteratorAnonymousInnerClassHelper2 : IEnumerator<long?>
+ private class IteratorAnonymousClass2 : IEnumerator<long?>
{
- public IteratorAnonymousInnerClassHelper2(IterableAnonymousInnerClassHelper2 outerInstance)
+ public IteratorAnonymousClass2(IterableAnonymousClass2 outerInstance)
{
@in = outerInstance.iterable.GetEnumerator();
}
@@ -160,29 +160,29 @@ namespace Lucene.Net.Codecs
/// Remaps every ord+1 on this enumerable. </summary>
public static IEnumerable<long?> MapAllOrds(IEnumerable<long?> iterable)
{
- return new IterableAnonymousInnerClassHelper3(iterable);
+ return new IterableAnonymousClass3(iterable);
}
- private class IterableAnonymousInnerClassHelper3 : IEnumerable<long?>
+ private class IterableAnonymousClass3 : IEnumerable<long?>
{
private readonly IEnumerable<long?> iterable;
- public IterableAnonymousInnerClassHelper3(IEnumerable<long?> iterable)
+ public IterableAnonymousClass3(IEnumerable<long?> iterable)
{
this.iterable = iterable;
}
public IEnumerator<long?> GetEnumerator()
{
- return new IteratorAnonymousInnerClassHelper3(this);
+ return new IteratorAnonymousClass3(this);
}
IEnumerator IEnumerable.GetEnumerator()
=> GetEnumerator();
- private class IteratorAnonymousInnerClassHelper3 : IEnumerator<long?>
+ private class IteratorAnonymousClass3 : IEnumerator<long?>
{
- public IteratorAnonymousInnerClassHelper3(IterableAnonymousInnerClassHelper3 outerInstance)
+ public IteratorAnonymousClass3(IterableAnonymousClass3 outerInstance)
{
@in = outerInstance.iterable.GetEnumerator();
}
diff --git a/src/Lucene.Net.TestFramework/Codecs/MockIntBlock/MockFixedIntBlockPostingsFormat.cs b/src/Lucene.Net.TestFramework/Codecs/MockIntBlock/MockFixedIntBlockPostingsFormat.cs
index 8c72c82..5e74d7a 100644
--- a/src/Lucene.Net.TestFramework/Codecs/MockIntBlock/MockFixedIntBlockPostingsFormat.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/MockIntBlock/MockFixedIntBlockPostingsFormat.cs
@@ -69,27 +69,27 @@ namespace Lucene.Net.Codecs.MockIntBlock
public override Int32IndexInput OpenInput(Directory dir, string fileName, IOContext context)
{
- return new FixedInt32BlockIndexInputAnonymousHelper(dir.OpenInput(fileName, context));
+ return new FixedInt32BlockIndexInputAnonymousClass(dir.OpenInput(fileName, context));
}
- private class FixedInt32BlockIndexInputAnonymousHelper : FixedInt32BlockIndexInput
+ private class FixedInt32BlockIndexInputAnonymousClass : FixedInt32BlockIndexInput
{
- public FixedInt32BlockIndexInputAnonymousHelper(IndexInput input)
+ public FixedInt32BlockIndexInputAnonymousClass(IndexInput input)
: base(input)
{
}
protected override IBlockReader GetBlockReader(IndexInput @in, int[] buffer)
{
- return new BlockReaderAnonymousHelper(@in, buffer);
+ return new BlockReaderAnonymousClass(@in, buffer);
}
- private class BlockReaderAnonymousHelper : FixedInt32BlockIndexInput.IBlockReader
+ private class BlockReaderAnonymousClass : FixedInt32BlockIndexInput.IBlockReader
{
private readonly IndexInput @in;
private readonly int[] buffer;
- public BlockReaderAnonymousHelper(IndexInput @in, int[] buffer)
+ public BlockReaderAnonymousClass(IndexInput @in, int[] buffer)
{
this.@in = @in;
this.buffer = buffer;
@@ -115,7 +115,7 @@ namespace Lucene.Net.Codecs.MockIntBlock
bool success = false;
try
{
- FixedInt32BlockIndexOutputAnonymousHelper ret = new FixedInt32BlockIndexOutputAnonymousHelper(output, blockSize);
+ FixedInt32BlockIndexOutputAnonymousClass ret = new FixedInt32BlockIndexOutputAnonymousClass(output, blockSize);
success = true;
return ret;
@@ -129,9 +129,9 @@ namespace Lucene.Net.Codecs.MockIntBlock
}
}
- private class FixedInt32BlockIndexOutputAnonymousHelper : FixedInt32BlockIndexOutput
+ private class FixedInt32BlockIndexOutputAnonymousClass : FixedInt32BlockIndexOutput
{
- public FixedInt32BlockIndexOutputAnonymousHelper(IndexOutput output, int blockSize)
+ public FixedInt32BlockIndexOutputAnonymousClass(IndexOutput output, int blockSize)
: base(output, blockSize)
{
}
diff --git a/src/Lucene.Net.TestFramework/Codecs/MockIntBlock/MockVariableIntBlockPostingsFormat.cs b/src/Lucene.Net.TestFramework/Codecs/MockIntBlock/MockVariableIntBlockPostingsFormat.cs
index 8835337..664db8e 100644
--- a/src/Lucene.Net.TestFramework/Codecs/MockIntBlock/MockVariableIntBlockPostingsFormat.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/MockIntBlock/MockVariableIntBlockPostingsFormat.cs
@@ -69,30 +69,30 @@ namespace Lucene.Net.Codecs.MockIntBlock
{
IndexInput input = dir.OpenInput(fileName, context);
int baseBlockSize = input.ReadInt32();
- return new VariableInt32BlockIndexInputAnonymousHelper(input, baseBlockSize);
+ return new VariableInt32BlockIndexInputAnonymousClass(input, baseBlockSize);
}
- private class VariableInt32BlockIndexInputAnonymousHelper : VariableInt32BlockIndexInput
+ private class VariableInt32BlockIndexInputAnonymousClass : VariableInt32BlockIndexInput
{
private readonly int baseBlockSize;
- public VariableInt32BlockIndexInputAnonymousHelper(IndexInput input, int baseBlockSize)
+ public VariableInt32BlockIndexInputAnonymousClass(IndexInput input, int baseBlockSize)
: base(input)
{
this.baseBlockSize = baseBlockSize;
}
protected override IBlockReader GetBlockReader(IndexInput @in, int[] buffer)
{
- return new BlockReaderAnonymousHelper(@in, buffer, baseBlockSize);
+ return new BlockReaderAnonymousClass(@in, buffer, baseBlockSize);
}
- private class BlockReaderAnonymousHelper : IBlockReader
+ private class BlockReaderAnonymousClass : IBlockReader
{
private readonly IndexInput input;
private readonly int[] buffer;
private readonly int baseBlockSize;
- public BlockReaderAnonymousHelper(IndexInput input, int[] buffer, int baseBlockSize)
+ public BlockReaderAnonymousClass(IndexInput input, int[] buffer, int baseBlockSize)
{
this.input = input;
this.buffer = buffer;
@@ -124,7 +124,7 @@ namespace Lucene.Net.Codecs.MockIntBlock
try
{
output.WriteInt32(baseBlockSize);
- VariableInt32BlockIndexOutput ret = new VariableInt32BlockIndexOutputAnonymousHelper(output, baseBlockSize);
+ VariableInt32BlockIndexOutput ret = new VariableInt32BlockIndexOutputAnonymousClass(output, baseBlockSize);
success = true;
return ret;
}
@@ -137,11 +137,11 @@ namespace Lucene.Net.Codecs.MockIntBlock
}
}
- private class VariableInt32BlockIndexOutputAnonymousHelper : VariableInt32BlockIndexOutput
+ private class VariableInt32BlockIndexOutputAnonymousClass : VariableInt32BlockIndexOutput
{
private readonly int baseBlockSize;
private readonly IndexOutput output;
- public VariableInt32BlockIndexOutputAnonymousHelper(IndexOutput output, int baseBlockSize)
+ public VariableInt32BlockIndexOutputAnonymousClass(IndexOutput output, int baseBlockSize)
: base(output, 2 * baseBlockSize)
{
this.output = output;
diff --git a/src/Lucene.Net.TestFramework/Codecs/MockRandom/MockRandomPostingsFormat.cs b/src/Lucene.Net.TestFramework/Codecs/MockRandom/MockRandomPostingsFormat.cs
index 417c68e..c43ebc0 100644
--- a/src/Lucene.Net.TestFramework/Codecs/MockRandom/MockRandomPostingsFormat.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/MockRandom/MockRandomPostingsFormat.cs
@@ -115,11 +115,11 @@ namespace Lucene.Net.Codecs.MockRandom
}
}
- private class IndexTermSelectorAnonymousHelper : VariableGapTermsIndexWriter.IndexTermSelector
+ private class IndexTermSelectorAnonymousClass : VariableGapTermsIndexWriter.IndexTermSelector
{
private readonly Random rand;
private readonly int gap;
- public IndexTermSelectorAnonymousHelper(int seed, int gap)
+ public IndexTermSelectorAnonymousClass(int seed, int gap)
{
rand = new Random(seed);
this.gap = gap;
@@ -315,7 +315,7 @@ namespace Lucene.Net.Codecs.MockRandom
{
Console.WriteLine("MockRandomCodec: random-gap terms index (max gap=" + gap + ")");
}
- selector = new IndexTermSelectorAnonymousHelper(seed2, gap);
+ selector = new IndexTermSelectorAnonymousClass(seed2, gap);
}
indexWriter = new VariableGapTermsIndexWriter(state, selector);
}
diff --git a/src/Lucene.Net.TestFramework/Codecs/RAMOnly/RAMOnlyPostingsFormat.cs b/src/Lucene.Net.TestFramework/Codecs/RAMOnly/RAMOnlyPostingsFormat.cs
index aee0430..bee1234 100644
--- a/src/Lucene.Net.TestFramework/Codecs/RAMOnly/RAMOnlyPostingsFormat.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/RAMOnly/RAMOnlyPostingsFormat.cs
@@ -41,13 +41,13 @@ namespace Lucene.Net.Codecs.RAMOnly
// For fun, test that we can override how terms are
// sorted, and basic things still work -- this comparer
// sorts in reversed unicode code point order:
- private static readonly IComparer<BytesRef> reverseUnicodeComparer = new ComparerAnonymousInnerClassHelper();
+ private static readonly IComparer<BytesRef> reverseUnicodeComparer = new ComparerAnonymousClass();
#pragma warning disable 659 // LUCENENET: Overrides Equals but not GetHashCode
- private class ComparerAnonymousInnerClassHelper : IComparer<BytesRef>
+ private class ComparerAnonymousClass : IComparer<BytesRef>
#pragma warning restore 659
{
- public ComparerAnonymousInnerClassHelper()
+ public ComparerAnonymousClass()
{ }
public virtual int Compare(BytesRef t1, BytesRef t2)
diff --git a/src/Lucene.Net.TestFramework/Index/BaseDocValuesFormatTestCase.cs b/src/Lucene.Net.TestFramework/Index/BaseDocValuesFormatTestCase.cs
index 1b003e6..8aaccc9 100644
--- a/src/Lucene.Net.TestFramework/Index/BaseDocValuesFormatTestCase.cs
+++ b/src/Lucene.Net.TestFramework/Index/BaseDocValuesFormatTestCase.cs
@@ -1308,15 +1308,15 @@ namespace Lucene.Net.Index
private void DoTestNumericsVsStoredFields(long minValue, long maxValue)
{
- DoTestNumericsVsStoredFields(new Int64ProducerAnonymousInnerClassHelper(minValue, maxValue));
+ DoTestNumericsVsStoredFields(new Int64ProducerAnonymousClass(minValue, maxValue));
}
- private class Int64ProducerAnonymousInnerClassHelper : Int64Producer
+ private class Int64ProducerAnonymousClass : Int64Producer
{
private readonly long minValue;
private readonly long maxValue;
- public Int64ProducerAnonymousInnerClassHelper(long minValue, long maxValue)
+ public Int64ProducerAnonymousClass(long minValue, long maxValue)
{
this.minValue = minValue;
this.maxValue = maxValue;
@@ -1390,15 +1390,15 @@ namespace Lucene.Net.Index
private void DoTestMissingVsFieldCache(long minValue, long maxValue)
{
- DoTestMissingVsFieldCache(new Int64ProducerAnonymousInnerClassHelper2(minValue, maxValue));
+ DoTestMissingVsFieldCache(new Int64ProducerAnonymousClass2(minValue, maxValue));
}
- private class Int64ProducerAnonymousInnerClassHelper2 : Int64Producer
+ private class Int64ProducerAnonymousClass2 : Int64Producer
{
private readonly long minValue;
private readonly long maxValue;
- public Int64ProducerAnonymousInnerClassHelper2(long minValue, long maxValue)
+ public Int64ProducerAnonymousClass2(long minValue, long maxValue)
{
this.minValue = minValue;
this.maxValue = maxValue;
@@ -2752,17 +2752,17 @@ namespace Lucene.Net.Index
{
long min = -(((long)Random.Next(1 << 30)) << 32);
long mul = Random.Next() & 0xFFFFFFFFL;
- Int64Producer longs = new Int64ProducerAnonymousInnerClassHelper3(min, mul);
+ Int64Producer longs = new Int64ProducerAnonymousClass3(min, mul);
DoTestNumericsVsStoredFields(longs);
}
}
- private class Int64ProducerAnonymousInnerClassHelper3 : Int64Producer
+ private class Int64ProducerAnonymousClass3 : Int64Producer
{
private readonly long min;
private readonly long mul;
- public Int64ProducerAnonymousInnerClassHelper3(long min, long mul)
+ public Int64ProducerAnonymousClass3(long min, long mul)
{
this.min = min;
this.mul = mul;
@@ -2788,12 +2788,12 @@ namespace Lucene.Net.Index
int numIterations = AtLeast(1);
for (int i = 0; i < numIterations; i++)
{
- Int64Producer longs = new Int64ProducerAnonymousInnerClassHelper4();
+ Int64Producer longs = new Int64ProducerAnonymousClass4();
DoTestNumericsVsStoredFields(longs);
}
}
- private class Int64ProducerAnonymousInnerClassHelper4 : Int64Producer
+ private class Int64ProducerAnonymousClass4 : Int64Producer
{
internal override long Next()
{
@@ -3307,7 +3307,7 @@ namespace Lucene.Net.Index
using CountdownEvent startingGun = new CountdownEvent(1);
for (int i = 0; i < threads.Length; i++)
{
- threads[i] = new ThreadAnonymousInnerClassHelper(ir, startingGun);
+ threads[i] = new ThreadAnonymousClass(ir, startingGun);
threads[i].Start();
}
startingGun.Signal();
@@ -3317,12 +3317,12 @@ namespace Lucene.Net.Index
}
}
- private class ThreadAnonymousInnerClassHelper : ThreadJob
+ private class ThreadAnonymousClass : ThreadJob
{
private readonly DirectoryReader ir;
private readonly CountdownEvent startingGun;
- public ThreadAnonymousInnerClassHelper(DirectoryReader ir, CountdownEvent startingGun)
+ public ThreadAnonymousClass(DirectoryReader ir, CountdownEvent startingGun)
{
this.ir = ir;
this.startingGun = startingGun;
@@ -3443,7 +3443,7 @@ namespace Lucene.Net.Index
using CountdownEvent startingGun = new CountdownEvent(1);
for (int i = 0; i < threads.Length; i++)
{
- threads[i] = new ThreadAnonymousInnerClassHelper2(ir, startingGun);
+ threads[i] = new ThreadAnonymousClass2(ir, startingGun);
threads[i].Start();
}
startingGun.Signal();
@@ -3453,12 +3453,12 @@ namespace Lucene.Net.Index
}
}
- private class ThreadAnonymousInnerClassHelper2 : ThreadJob
+ private class ThreadAnonymousClass2 : ThreadJob
{
private readonly DirectoryReader ir;
private readonly CountdownEvent startingGun;
- public ThreadAnonymousInnerClassHelper2(DirectoryReader ir, CountdownEvent startingGun)
+ public ThreadAnonymousClass2(DirectoryReader ir, CountdownEvent startingGun)
{
this.ir = ir;
this.startingGun = startingGun;
diff --git a/src/Lucene.Net.TestFramework/Index/BaseMergePolicyTestCase.cs b/src/Lucene.Net.TestFramework/Index/BaseMergePolicyTestCase.cs
index fe3d36b..b24e256 100644
--- a/src/Lucene.Net.TestFramework/Index/BaseMergePolicyTestCase.cs
+++ b/src/Lucene.Net.TestFramework/Index/BaseMergePolicyTestCase.cs
@@ -56,7 +56,7 @@ namespace Lucene.Net.Index
{
using Directory dir = NewDirectory();
AtomicBoolean mayMerge = new AtomicBoolean(true);
- MergeScheduler mergeScheduler = new SerialMergeSchedulerAnonymousInnerClassHelper(mayMerge);
+ MergeScheduler mergeScheduler = new SerialMergeSchedulerAnonymousClass(mayMerge);
using IndexWriter writer = new IndexWriter(dir, NewIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(Random)).SetMergeScheduler(mergeScheduler).SetMergePolicy(NewMergePolicy()));
writer.Config.MergePolicy.NoCFSRatio = Random.NextBoolean() ? 0 : 1;
int numSegments = TestUtil.NextInt32(Random, 2, 20);
@@ -78,11 +78,11 @@ namespace Lucene.Net.Index
}
}
- private class SerialMergeSchedulerAnonymousInnerClassHelper : SerialMergeScheduler
+ private class SerialMergeSchedulerAnonymousClass : SerialMergeScheduler
{
private readonly AtomicBoolean mayMerge;
- public SerialMergeSchedulerAnonymousInnerClassHelper(AtomicBoolean mayMerge)
+ public SerialMergeSchedulerAnonymousClass(AtomicBoolean mayMerge)
{
this.mayMerge = mayMerge;
}
diff --git a/src/Lucene.Net.TestFramework/Index/BaseStoredFieldsFormatTestCase.cs b/src/Lucene.Net.TestFramework/Index/BaseStoredFieldsFormatTestCase.cs
index 78ad27a..2b779e8 100644
--- a/src/Lucene.Net.TestFramework/Index/BaseStoredFieldsFormatTestCase.cs
+++ b/src/Lucene.Net.TestFramework/Index/BaseStoredFieldsFormatTestCase.cs
@@ -501,7 +501,7 @@ namespace Lucene.Net.Index
for (int i = 0; i < concurrentReads; ++i)
{
- readThreads.Add(new ThreadAnonymousInnerClassHelper(numDocs, rd, searcher, readsPerThread, ex));
+ readThreads.Add(new ThreadAnonymousClass(numDocs, rd, searcher, readsPerThread, ex));
}
foreach (ThreadJob thread in readThreads)
{
@@ -518,7 +518,7 @@ namespace Lucene.Net.Index
}
}
- private class ThreadAnonymousInnerClassHelper : ThreadJob
+ private class ThreadAnonymousClass : ThreadJob
{
private readonly int numDocs;
private readonly DirectoryReader rd;
@@ -527,7 +527,7 @@ namespace Lucene.Net.Index
private readonly AtomicReference<Exception> ex;
private readonly int[] queries;
- public ThreadAnonymousInnerClassHelper(int numDocs, DirectoryReader rd, IndexSearcher searcher, int readsPerThread, AtomicReference<Exception> ex)
+ public ThreadAnonymousClass(int numDocs, DirectoryReader rd, IndexSearcher searcher, int readsPerThread, AtomicReference<Exception> ex)
{
this.numDocs = numDocs;
this.rd = rd;
diff --git a/src/Lucene.Net.TestFramework/Index/BaseTermVectorsFormatTestCase.cs b/src/Lucene.Net.TestFramework/Index/BaseTermVectorsFormatTestCase.cs
index 783fcb1..f923bf7 100644
--- a/src/Lucene.Net.TestFramework/Index/BaseTermVectorsFormatTestCase.cs
+++ b/src/Lucene.Net.TestFramework/Index/BaseTermVectorsFormatTestCase.cs
@@ -920,7 +920,7 @@ namespace Lucene.Net.Index
ThreadJob[] threads = new ThreadJob[2];
for (int i = 0; i < threads.Length; ++i)
{
- threads[i] = new ThreadAnonymousInnerClassHelper(this, numDocs, docs, reader, exception);
+ threads[i] = new ThreadAnonymousClass(this, numDocs, docs, reader, exception);
}
foreach (ThreadJob thread in threads)
{
@@ -935,7 +935,7 @@ namespace Lucene.Net.Index
}
}
- private class ThreadAnonymousInnerClassHelper : ThreadJob
+ private class ThreadAnonymousClass : ThreadJob
{
private readonly BaseTermVectorsFormatTestCase outerInstance;
@@ -944,7 +944,7 @@ namespace Lucene.Net.Index
private readonly IndexReader reader;
private readonly AtomicReference<Exception> exception;
- public ThreadAnonymousInnerClassHelper(BaseTermVectorsFormatTestCase outerInstance, int numDocs, RandomDocument[] docs, IndexReader reader, AtomicReference<Exception> exception)
+ public ThreadAnonymousClass(BaseTermVectorsFormatTestCase outerInstance, int numDocs, RandomDocument[] docs, IndexReader reader, AtomicReference<Exception> exception)
{
this.outerInstance = outerInstance;
this.numDocs = numDocs;
diff --git a/src/Lucene.Net.TestFramework/Index/FieldFilterAtomicReader.cs b/src/Lucene.Net.TestFramework/Index/FieldFilterAtomicReader.cs
index 4dbb538..8b54df3 100644
--- a/src/Lucene.Net.TestFramework/Index/FieldFilterAtomicReader.cs
+++ b/src/Lucene.Net.TestFramework/Index/FieldFilterAtomicReader.cs
@@ -71,16 +71,16 @@ namespace Lucene.Net.Index
public override void Document(int docID, StoredFieldVisitor visitor)
{
- base.Document(docID, new StoredFieldVisitorAnonymousInnerClassHelper(this, visitor));
+ base.Document(docID, new StoredFieldVisitorAnonymousClass(this, visitor));
}
- private class StoredFieldVisitorAnonymousInnerClassHelper : StoredFieldVisitor
+ private class StoredFieldVisitorAnonymousClass : StoredFieldVisitor
{
private readonly FieldFilterAtomicReader outerInstance;
private readonly StoredFieldVisitor visitor;
- public StoredFieldVisitorAnonymousInnerClassHelper(FieldFilterAtomicReader outerInstance, StoredFieldVisitor visitor)
+ public StoredFieldVisitorAnonymousClass(FieldFilterAtomicReader outerInstance, StoredFieldVisitor visitor)
{
this.outerInstance = outerInstance;
this.visitor = visitor;
diff --git a/src/Lucene.Net.TestFramework/Index/RandomIndexWriter.cs b/src/Lucene.Net.TestFramework/Index/RandomIndexWriter.cs
index 892bce2..fc3069e 100644
--- a/src/Lucene.Net.TestFramework/Index/RandomIndexWriter.cs
+++ b/src/Lucene.Net.TestFramework/Index/RandomIndexWriter.cs
@@ -48,14 +48,14 @@ namespace Lucene.Net.Index
{
// Randomly calls Thread.yield so we mixup thread scheduling
Random random = new Random(r.Next());
- return MockIndexWriter(dir, conf, new TestPointAnonymousInnerClassHelper(random));
+ return MockIndexWriter(dir, conf, new TestPointAnonymousClass(random));
}
- private class TestPointAnonymousInnerClassHelper : ITestPoint
+ private class TestPointAnonymousClass : ITestPoint
{
private readonly Random random;
- public TestPointAnonymousInnerClassHelper(Random random)
+ public TestPointAnonymousClass(Random random)
{
this.random = random;
}
@@ -191,7 +191,7 @@ namespace Lucene.Net.Index
// (but we need to clone them), and only when
// getReader, commit, etc. are called, we do an
// addDocuments? Would be better testing.
- IndexWriter.AddDocuments(new IterableAnonymousInnerClassHelper<IIndexableField>(doc), a);
+ IndexWriter.AddDocuments(new IterableAnonymousClass<IIndexableField>(doc), a);
}
else
{
@@ -201,18 +201,18 @@ namespace Lucene.Net.Index
MaybeCommit();
}
- private class IterableAnonymousInnerClassHelper<IndexableField> : IEnumerable<IEnumerable<IndexableField>>
+ private class IterableAnonymousClass<IndexableField> : IEnumerable<IEnumerable<IndexableField>>
{
private readonly IEnumerable<IndexableField> doc;
- public IterableAnonymousInnerClassHelper(IEnumerable<IndexableField> doc)
+ public IterableAnonymousClass(IEnumerable<IndexableField> doc)
{
this.doc = doc;
}
public IEnumerator<IEnumerable<IndexableField>> GetEnumerator()
{
- return new IteratorAnonymousInnerClassHelper(this);
+ return new IteratorAnonymousClass(this);
}
IEnumerator IEnumerable.GetEnumerator()
@@ -220,11 +220,11 @@ namespace Lucene.Net.Index
return GetEnumerator();
}
- private class IteratorAnonymousInnerClassHelper : IEnumerator<IEnumerable<IndexableField>>
+ private class IteratorAnonymousClass : IEnumerator<IEnumerable<IndexableField>>
{
- private readonly IterableAnonymousInnerClassHelper<IndexableField> outerInstance;
+ private readonly IterableAnonymousClass<IndexableField> outerInstance;
- public IteratorAnonymousInnerClassHelper(IterableAnonymousInnerClassHelper<IndexableField> outerInstance)
+ public IteratorAnonymousClass(IterableAnonymousClass<IndexableField> outerInstance)
{
this.outerInstance = outerInstance;
}
@@ -294,7 +294,7 @@ namespace Lucene.Net.Index
{
if (r.Next(5) == 3)
{
- IndexWriter.UpdateDocuments(t, new IterableAnonymousInnerClassHelper2(doc));
+ IndexWriter.UpdateDocuments(t, new IterableAnonymousClass2(doc));
}
else
{
@@ -303,28 +303,28 @@ namespace Lucene.Net.Index
MaybeCommit();
}
- private class IterableAnonymousInnerClassHelper2 : IEnumerable<IEnumerable<IIndexableField>>
+ private class IterableAnonymousClass2 : IEnumerable<IEnumerable<IIndexableField>>
{
private readonly IEnumerable<IIndexableField> doc;
- public IterableAnonymousInnerClassHelper2(IEnumerable<IIndexableField> doc)
+ public IterableAnonymousClass2(IEnumerable<IIndexableField> doc)
{
this.doc = doc;
}
public IEnumerator<IEnumerable<IIndexableField>> GetEnumerator()
{
- return new IteratorAnonymousInnerClassHelper2(this);
+ return new IteratorAnonymousClass2(this);
}
IEnumerator IEnumerable.GetEnumerator()
=> GetEnumerator();
- private class IteratorAnonymousInnerClassHelper2 : IEnumerator<IEnumerable<IIndexableField>>
+ private class IteratorAnonymousClass2 : IEnumerator<IEnumerable<IIndexableField>>
{
- private readonly IterableAnonymousInnerClassHelper2 outerInstance;
+ private readonly IterableAnonymousClass2 outerInstance;
- public IteratorAnonymousInnerClassHelper2(IterableAnonymousInnerClassHelper2 outerInstance)
+ public IteratorAnonymousClass2(IterableAnonymousClass2 outerInstance)
{
this.outerInstance = outerInstance;
}
diff --git a/src/Lucene.Net.TestFramework/Index/ThreadedIndexingAndSearchingTestCase.cs b/src/Lucene.Net.TestFramework/Index/ThreadedIndexingAndSearchingTestCase.cs
index bf23258..be5d616 100644
--- a/src/Lucene.Net.TestFramework/Index/ThreadedIndexingAndSearchingTestCase.cs
+++ b/src/Lucene.Net.TestFramework/Index/ThreadedIndexingAndSearchingTestCase.cs
@@ -141,7 +141,7 @@ namespace Lucene.Net.Index
ThreadJob[] threads = new ThreadJob[numThreads];
for (int thread = 0; thread < numThreads; thread++)
{
- threads[thread] = new ThreadAnonymousInnerClassHelper(this, docs, stopTime, delIDs, delPackIDs, allSubDocs);
+ threads[thread] = new ThreadAnonymousClass(this, docs, stopTime, delIDs, delPackIDs, allSubDocs);
threads[thread].IsBackground = (true);
threads[thread].Start();
}
@@ -149,7 +149,7 @@ namespace Lucene.Net.Index
return threads;
}
- private class ThreadAnonymousInnerClassHelper : ThreadJob
+ private class ThreadAnonymousClass : ThreadJob
{
private readonly ThreadedIndexingAndSearchingTestCase outerInstance;
@@ -159,7 +159,7 @@ namespace Lucene.Net.Index
private readonly ISet<string> delPackIDs;
private readonly ConcurrentQueue<SubDocs> allSubDocs;
- public ThreadAnonymousInnerClassHelper(ThreadedIndexingAndSearchingTestCase outerInstance, LineFileDocs docs, long stopTime, ISet<string> delIDs, ISet<string> delPackIDs, ConcurrentQueue<SubDocs> allSubDocs)
+ public ThreadAnonymousClass(ThreadedIndexingAndSearchingTestCase outerInstance, LineFileDocs docs, long stopTime, ISet<string> delIDs, ISet<string> delPackIDs, ConcurrentQueue<SubDocs> allSubDocs)
{
this.outerInstance = outerInstance;
this.docs = docs;
@@ -415,7 +415,7 @@ namespace Lucene.Net.Index
// TODO: we should enrich this to do more interesting searches
for (int thread = 0; thread < searchThreads.Length; thread++)
{
- searchThreads[thread] = new ThreadAnonymousInnerClassHelper2(this, stopTime, totHits, totTermCount);
+ searchThreads[thread] = new ThreadAnonymousClass2(this, stopTime, totHits, totTermCount);
searchThreads[thread].IsBackground = (true);
searchThreads[thread].Start();
}
@@ -431,7 +431,7 @@ namespace Lucene.Net.Index
}
}
- private class ThreadAnonymousInnerClassHelper2 : ThreadJob
+ private class ThreadAnonymousClass2 : ThreadJob
{
private readonly ThreadedIndexingAndSearchingTestCase outerInstance;
@@ -439,7 +439,7 @@ namespace Lucene.Net.Index
private readonly AtomicInt32 totHits;
private readonly AtomicInt32 totTermCount;
- public ThreadAnonymousInnerClassHelper2(ThreadedIndexingAndSearchingTestCase outerInstance, long stopTimeMS, AtomicInt32 totHits, AtomicInt32 totTermCount)
+ public ThreadAnonymousClass2(ThreadedIndexingAndSearchingTestCase outerInstance, long stopTimeMS, AtomicInt32 totHits, AtomicInt32 totTermCount)
{
this.outerInstance = outerInstance;
this.stopTimeMS = stopTimeMS;
@@ -602,11 +602,11 @@ namespace Lucene.Net.Index
}
}
- conf.SetMergedSegmentWarmer(new IndexReaderWarmerAnonymousInnerClassHelper(this));
+ conf.SetMergedSegmentWarmer(new IndexReaderWarmerAnonymousClass(this));
if (Verbose)
{
- conf.SetInfoStream(new PrintStreamInfoStreamAnonymousInnerClassHelper(Console.Out));
+ conf.SetInfoStream(new PrintStreamInfoStreamAnonymousClass(Console.Out));
}
m_writer = new IndexWriter(m_dir, conf);
TestUtil.ReduceOpenFiles(m_writer);
@@ -795,11 +795,11 @@ namespace Lucene.Net.Index
}
}
- private class IndexReaderWarmerAnonymousInnerClassHelper : IndexWriter.IndexReaderWarmer
+ private class IndexReaderWarmerAnonymousClass : IndexWriter.IndexReaderWarmer
{
private readonly ThreadedIndexingAndSearchingTestCase outerInstance;
- public IndexReaderWarmerAnonymousInnerClassHelper(ThreadedIndexingAndSearchingTestCase outerInstance)
+ public IndexReaderWarmerAnonymousClass(ThreadedIndexingAndSearchingTestCase outerInstance)
{
this.outerInstance = outerInstance;
}
@@ -842,9 +842,9 @@ namespace Lucene.Net.Index
}
}
- private class PrintStreamInfoStreamAnonymousInnerClassHelper : TextWriterInfoStream
+ private class PrintStreamInfoStreamAnonymousClass : TextWriterInfoStream
{
- public PrintStreamInfoStreamAnonymousInnerClassHelper(TextWriter @out)
+ public PrintStreamInfoStreamAnonymousClass(TextWriter @out)
: base(@out)
{
}
diff --git a/src/Lucene.Net.TestFramework/Search/AssertingIndexSearcher.cs b/src/Lucene.Net.TestFramework/Search/AssertingIndexSearcher.cs
index d753f1c..ef44f4a 100644
--- a/src/Lucene.Net.TestFramework/Search/AssertingIndexSearcher.cs
+++ b/src/Lucene.Net.TestFramework/Search/AssertingIndexSearcher.cs
@@ -60,12 +60,12 @@ namespace Lucene.Net.Search
public override Weight CreateNormalizedWeight(Query query)
{
Weight w = base.CreateNormalizedWeight(query);
- return new AssertingWeightAnonymousInnerClassHelper(random, w);
+ return new AssertingWeightAnonymousClass(random, w);
}
- private class AssertingWeightAnonymousInnerClassHelper : AssertingWeight
+ private class AssertingWeightAnonymousClass : AssertingWeight
{
- public AssertingWeightAnonymousInnerClassHelper(Random random, Weight w)
+ public AssertingWeightAnonymousClass(Random random, Weight w)
: base(random, w)
{
}
diff --git a/src/Lucene.Net.TestFramework/Search/QueryUtils.cs b/src/Lucene.Net.TestFramework/Search/QueryUtils.cs
index 7331687..083db1c 100644
--- a/src/Lucene.Net.TestFramework/Search/QueryUtils.cs
+++ b/src/Lucene.Net.TestFramework/Search/QueryUtils.cs
@@ -74,7 +74,7 @@ namespace Lucene.Net.Search
// test that a class check is done so that no exception is thrown
// in the implementation of equals()
- Query whacky = new QueryAnonymousInnerClassHelper();
+ Query whacky = new QueryAnonymousClass();
whacky.Boost = q.Boost;
CheckUnequal(q, whacky);
@@ -82,9 +82,9 @@ namespace Lucene.Net.Search
Assert.IsFalse(q.Equals(null));
}
- private class QueryAnonymousInnerClassHelper : Query
+ private class QueryAnonymousClass : Query
{
- public QueryAnonymousInnerClassHelper()
+ public QueryAnonymousClass()
{
}
@@ -351,7 +351,7 @@ namespace Lucene.Net.Search
const float maxDiff = 1e-5f;
AtomicReader[] lastReader = new AtomicReader[] { null };
- s.Search(q, new CollectorAnonymousInnerClassHelper(
+ s.Search(q, new CollectorAnonymousClass(
#if FEATURE_INSTANCE_TESTDATA_INITIALIZATION
luceneTestCase,
#endif
@@ -380,7 +380,7 @@ namespace Lucene.Net.Search
}
}
- private class CollectorAnonymousInnerClassHelper : ICollector
+ private class CollectorAnonymousClass : ICollector
{
#if FEATURE_INSTANCE_TESTDATA_INITIALIZATION
private readonly LuceneTestCase luceneTestCase;
@@ -395,7 +395,7 @@ namespace Lucene.Net.Search
private readonly float maxDiff;
private readonly AtomicReader[] lastReader;
- public CollectorAnonymousInnerClassHelper(
+ public CollectorAnonymousClass(
#if FEATURE_INSTANCE_TESTDATA_INITIALIZATION
LuceneTestCase luceneTestCase,
#endif
@@ -515,7 +515,7 @@ namespace Lucene.Net.Search
int[] lastDoc = new int[] { -1 };
AtomicReader[] lastReader = new AtomicReader[] { null };
IList<AtomicReaderContext> context = s.TopReaderContext.Leaves;
- s.Search(q, new CollectorAnonymousInnerClassHelper2(
+ s.Search(q, new CollectorAnonymousClass2(
#if FEATURE_INSTANCE_TESTDATA_INITIALIZATION
luceneTestCase,
#endif
@@ -542,7 +542,7 @@ namespace Lucene.Net.Search
}
}
- private class CollectorAnonymousInnerClassHelper2 : ICollector
+ private class CollectorAnonymousClass2 : ICollector
{
#if FEATURE_INSTANCE_TESTDATA_INITIALIZATION
private readonly LuceneTestCase luceneTestCase;
@@ -554,7 +554,7 @@ namespace Lucene.Net.Search
private readonly AtomicReader[] lastReader;
private readonly IList<AtomicReaderContext> context;
- public CollectorAnonymousInnerClassHelper2(
+ public CollectorAnonymousClass2(
#if FEATURE_INSTANCE_TESTDATA_INITIALIZATION
LuceneTestCase luceneTestCase,
#endif
diff --git a/src/Lucene.Net.TestFramework/Store/MockDirectoryWrapper.cs b/src/Lucene.Net.TestFramework/Store/MockDirectoryWrapper.cs
index a7f51d3..41dd014 100644
--- a/src/Lucene.Net.TestFramework/Store/MockDirectoryWrapper.cs
+++ b/src/Lucene.Net.TestFramework/Store/MockDirectoryWrapper.cs
@@ -1227,19 +1227,19 @@ namespace Lucene.Net.Store
}
IndexInputSlicer delegateHandle = m_input.CreateSlicer(name, context);
- IndexInputSlicer handle = new IndexInputSlicerAnonymousInnerClassHelper(this, name, delegateHandle);
+ IndexInputSlicer handle = new IndexInputSlicerAnonymousClass(this, name, delegateHandle);
AddFileHandle(handle, name, Handle.Slice);
return handle;
}
- private class IndexInputSlicerAnonymousInnerClassHelper : IndexInputSlicer
+ private class IndexInputSlicerAnonymousClass : IndexInputSlicer
{
private readonly MockDirectoryWrapper outerInstance;
private readonly string name;
private readonly IndexInputSlicer delegateHandle;
- public IndexInputSlicerAnonymousInnerClassHelper(MockDirectoryWrapper outerInstance, string name, IndexInputSlicer delegateHandle)
+ public IndexInputSlicerAnonymousClass(MockDirectoryWrapper outerInstance, string name, IndexInputSlicer delegateHandle)
{
this.outerInstance = outerInstance;
this.name = name;
diff --git a/src/Lucene.Net.TestFramework/Util/LuceneTestCase.cs b/src/Lucene.Net.TestFramework/Util/LuceneTestCase.cs
index 70a99d2..c2a9b03 100644
--- a/src/Lucene.Net.TestFramework/Util/LuceneTestCase.cs
+++ b/src/Lucene.Net.TestFramework/Util/LuceneTestCase.cs
@@ -2412,7 +2412,7 @@ namespace Lucene.Net.Util
{
Console.WriteLine("NOTE: newSearcher using ExecutorService with " + threads + " threads");
}
- //r.AddReaderClosedListener(new ReaderClosedListenerAnonymousInnerClassHelper(ex)); // LUCENENET TODO: Implement event (see the commented ReaderClosedListenerAnonymousInnerClassHelper class near the bottom of this file)
+ //r.AddReaderClosedListener(new ReaderClosedListenerAnonymousClass(ex)); // LUCENENET TODO: Implement event (see the commented ReaderClosedListenerAnonymousClass class near the bottom of this file)
}
IndexSearcher ret;
if (wrapWithAssertions)
@@ -3639,11 +3639,11 @@ namespace Lucene.Net.Util
}
}
- //internal class ReaderClosedListenerAnonymousInnerClassHelper : IndexReader.IReaderClosedListener
+ //internal class ReaderClosedListenerAnonymousClass : IndexReader.IReaderClosedListener
//{
// private TaskScheduler ex;
- // public ReaderClosedListenerAnonymousInnerClassHelper(TaskScheduler ex)
+ // public ReaderClosedListenerAnonymousClass(TaskScheduler ex)
// {
// this.ex = ex;
// }
diff --git a/src/Lucene.Net.TestFramework/Util/TestRuleAssertionsRequired.cs b/src/Lucene.Net.TestFramework/Util/TestRuleAssertionsRequired.cs
index fa25854..436d752 100644
--- a/src/Lucene.Net.TestFramework/Util/TestRuleAssertionsRequired.cs
+++ b/src/Lucene.Net.TestFramework/Util/TestRuleAssertionsRequired.cs
@@ -35,17 +35,17 @@ namespace Lucene.Net.Util
{
public override Statement Apply(Statement @base, Description description)
{
- return new StatementAnonymousInnerClassHelper(this, @base, description);
+ return new StatementAnonymousClass(this, @base, description);
}
- private class StatementAnonymousInnerClassHelper : Statement
+ private class StatementAnonymousClass : Statement
{
private readonly TestRuleAssertionsRequired OuterInstance;
private Statement @base;
private Description Description;
- public StatementAnonymousInnerClassHelper(TestRuleAssertionsRequired outerInstance, Statement @base, Description description)
+ public StatementAnonymousClass(TestRuleAssertionsRequired outerInstance, Statement @base, Description description)
{
this.OuterInstance = outerInstance;
this.@base = @base;
diff --git a/src/Lucene.Net.TestFramework/Util/TestRuleFieldCacheSanity.cs b/src/Lucene.Net.TestFramework/Util/TestRuleFieldCacheSanity.cs
index 136566e..fc9a350 100644
--- a/src/Lucene.Net.TestFramework/Util/TestRuleFieldCacheSanity.cs
+++ b/src/Lucene.Net.TestFramework/Util/TestRuleFieldCacheSanity.cs
@@ -50,17 +50,17 @@ namespace Lucene.Net.Util
public override Statement Apply(Statement s, Description d)
{
- return new StatementAnonymousInnerClassHelper(this, s, d);
+ return new StatementAnonymousClass(this, s, d);
}
- private class StatementAnonymousInnerClassHelper : Statement
+ private class StatementAnonymousClass : Statement
{
private readonly TestRuleFieldCacheSanity OuterInstance;
private Statement s;
private Description d;
- public StatementAnonymousInnerClassHelper(TestRuleFieldCacheSanity outerInstance, Statement s, Description d)
+ public StatementAnonymousClass(TestRuleFieldCacheSanity outerInstance, Statement s, Description d)
{
this.OuterInstance = outerInstance;
this.s = s;
diff --git a/src/Lucene.Net.TestFramework/Util/TestRuleIgnoreAfterMaxFailures.cs b/src/Lucene.Net.TestFramework/Util/TestRuleIgnoreAfterMaxFailures.cs
index daa6a40..64ae2bf 100644
--- a/src/Lucene.Net.TestFramework/Util/TestRuleIgnoreAfterMaxFailures.cs
+++ b/src/Lucene.Net.TestFramework/Util/TestRuleIgnoreAfterMaxFailures.cs
@@ -57,16 +57,16 @@ namespace Lucene.Net.Util
public override Statement Apply(Statement s, Description d)
{
- return new StatementAnonymousInnerClassHelper(this, s);
+ return new StatementAnonymousClass(this, s);
}
- private class StatementAnonymousInnerClassHelper : Statement
+ private class StatementAnonymousClass : Statement
{
private readonly TestRuleIgnoreAfterMaxFailures OuterInstance;
private Statement s;
- public StatementAnonymousInnerClassHelper(TestRuleIgnoreAfterMaxFailures outerInstance, Statement s)
+ public StatementAnonymousClass(TestRuleIgnoreAfterMaxFailures outerInstance, Statement s)
{
this.OuterInstance = outerInstance;
this.s = s;
diff --git a/src/Lucene.Net.TestFramework/Util/TestRuleIgnoreTestSuites.cs b/src/Lucene.Net.TestFramework/Util/TestRuleIgnoreTestSuites.cs
index d13eeca..c2c40bb 100644
--- a/src/Lucene.Net.TestFramework/Util/TestRuleIgnoreTestSuites.cs
+++ b/src/Lucene.Net.TestFramework/Util/TestRuleIgnoreTestSuites.cs
@@ -51,17 +51,17 @@ namespace Lucene.Net.Util
public override Statement Apply(Statement s, Description d)
{
- return new StatementAnonymousInnerClassHelper(this, s, d);
+ return new StatementAnonymousClass(this, s, d);
}
- private class StatementAnonymousInnerClassHelper : Statement
+ private class StatementAnonymousClass : Statement
{
private readonly TestRuleIgnoreTestSuites OuterInstance;
private Statement s;
private Description d;
- public StatementAnonymousInnerClassHelper(TestRuleIgnoreTestSuites outerInstance, Statement s, Description d)
+ public StatementAnonymousClass(TestRuleIgnoreTestSuites outerInstance, Statement s, Description d)
{
this.OuterInstance = outerInstance;
this.s = s;
diff --git a/src/Lucene.Net.TestFramework/Util/TestRuleMarkFailure.cs b/src/Lucene.Net.TestFramework/Util/TestRuleMarkFailure.cs
index 776a42d..5aa27e6 100644
--- a/src/Lucene.Net.TestFramework/Util/TestRuleMarkFailure.cs
+++ b/src/Lucene.Net.TestFramework/Util/TestRuleMarkFailure.cs
@@ -44,16 +44,16 @@ namespace Lucene.Net.Util
public override Statement Apply(Statement s, Description d)
{
- return new StatementAnonymousInnerClassHelper(this, s);
+ return new StatementAnonymousClass(this, s);
}
- private class StatementAnonymousInnerClassHelper : Statement
+ private class StatementAnonymousClass : Statement
{
private readonly TestRuleMarkFailure OuterInstance;
private Statement s;
- public StatementAnonymousInnerClassHelper(TestRuleMarkFailure outerInstance, Statement s)
+ public StatementAnonymousClass(TestRuleMarkFailure outerInstance, Statement s)
{
this.OuterInstance = outerInstance;
this.s = s;
diff --git a/src/Lucene.Net.TestFramework/Util/TestRuleSetupAndRestoreClassEnv.cs b/src/Lucene.Net.TestFramework/Util/TestRuleSetupAndRestoreClassEnv.cs
index 43e6aab..0c833a5 100644
--- a/src/Lucene.Net.TestFramework/Util/TestRuleSetupAndRestoreClassEnv.cs
+++ b/src/Lucene.Net.TestFramework/Util/TestRuleSetupAndRestoreClassEnv.cs
@@ -242,7 +242,7 @@ namespace Lucene.Net.Util
dvFormat = DocValuesFormat.ForName(LuceneTestCase.TestDocValuesFormat);
}
- codec = new Lucene46CodecAnonymousInnerClassHelper(format, dvFormat);
+ codec = new Lucene46CodecAnonymousClass(format, dvFormat);
}
else if ("SimpleText".Equals(LuceneTestCase.TestCodec, StringComparison.Ordinal)
|| ("random".Equals(LuceneTestCase.TestCodec, StringComparison.Ordinal) && randomVal == 9 && LuceneTestCase.Rarely(random) && !ShouldAvoidCodec("SimpleText")))
@@ -315,12 +315,12 @@ namespace Lucene.Net.Util
}
}
- private class Lucene46CodecAnonymousInnerClassHelper : Lucene46Codec
+ private class Lucene46CodecAnonymousClass : Lucene46Codec
{
private readonly PostingsFormat format;
private readonly DocValuesFormat dvFormat;
- public Lucene46CodecAnonymousInnerClassHelper(PostingsFormat format, DocValuesFormat dvFormat)
+ public Lucene46CodecAnonymousClass(PostingsFormat format, DocValuesFormat dvFormat)
{
this.format = format;
this.dvFormat = dvFormat;
diff --git a/src/Lucene.Net.TestFramework/Util/TestRuleSetupTeardownChained.cs b/src/Lucene.Net.TestFramework/Util/TestRuleSetupTeardownChained.cs
index 19c728f..6bf74fc 100644
--- a/src/Lucene.Net.TestFramework/Util/TestRuleSetupTeardownChained.cs
+++ b/src/Lucene.Net.TestFramework/Util/TestRuleSetupTeardownChained.cs
@@ -43,16 +43,16 @@ namespace Lucene.Net.Util
public override Statement Apply(Statement @base, Description description)
{
- return new StatementAnonymousInnerClassHelper(this, @base);
+ return new StatementAnonymousClass(this, @base);
}
- private class StatementAnonymousInnerClassHelper : Statement
+ private class StatementAnonymousClass : Statement
{
private readonly TestRuleSetupTeardownChained OuterInstance;
private Statement @base;
- public StatementAnonymousInnerClassHelper(TestRuleSetupTeardownChained outerInstance, Statement @base)
+ public StatementAnonymousClass(TestRuleSetupTeardownChained outerInstance, Statement @base)
{
this.OuterInstance = outerInstance;
this.@base = @base;
diff --git a/src/Lucene.Net.TestFramework/Util/TestRuleStoreClassName.cs b/src/Lucene.Net.TestFramework/Util/TestRuleStoreClassName.cs
index b837d10..0c7e5cd 100644
--- a/src/Lucene.Net.TestFramework/Util/TestRuleStoreClassName.cs
+++ b/src/Lucene.Net.TestFramework/Util/TestRuleStoreClassName.cs
@@ -41,17 +41,17 @@ namespace Lucene.Net.Util
throw new ArgumentException("this is a @ClassRule (applies to suites only).");
}
- return new StatementAnonymousInnerClassHelper(this, s, d);
+ return new StatementAnonymousClass(this, s, d);
}
- private class StatementAnonymousInnerClassHelper : Statement
+ private class StatementAnonymousClass : Statement
{
private readonly TestRuleStoreClassName OuterInstance;
private Statement s;
private Description d;
- public StatementAnonymousInnerClassHelper(TestRuleStoreClassName outerInstance, Statement s, Description d)
+ public StatementAnonymousClass(TestRuleStoreClassName outerInstance, Statement s, Description d)
{
this.OuterInstance = outerInstance;
this.s = s;
diff --git a/src/Lucene.Net.TestFramework/Util/TestRuleThreadAndTestName.cs b/src/Lucene.Net.TestFramework/Util/TestRuleThreadAndTestName.cs
index 79d2420..61a8d13 100644
--- a/src/Lucene.Net.TestFramework/Util/TestRuleThreadAndTestName.cs
+++ b/src/Lucene.Net.TestFramework/Util/TestRuleThreadAndTestName.cs
@@ -43,17 +43,17 @@ namespace Lucene.Net.Util
public override Statement Apply(Statement @base, Description description)
{
- return new StatementAnonymousInnerClassHelper(this, @base, description);
+ return new StatementAnonymousClass(this, @base, description);
}
- private class StatementAnonymousInnerClassHelper : Statement
+ private class StatementAnonymousClass : Statement
{
private readonly TestRuleThreadAndTestName OuterInstance;
private Statement @base;
private Description Description;
- public StatementAnonymousInnerClassHelper(TestRuleThreadAndTestName outerInstance, Statement @base, Description description)
+ public StatementAnonymousClass(TestRuleThreadAndTestName outerInstance, Statement @base, Description description)
{
this.OuterInstance = outerInstance;
this.@base = @base;
diff --git a/src/Lucene.Net.TestFramework/Util/TestSecurityManager.cs b/src/Lucene.Net.TestFramework/Util/TestSecurityManager.cs
index 50fc1b0..a4fd088 100644
--- a/src/Lucene.Net.TestFramework/Util/TestSecurityManager.cs
+++ b/src/Lucene.Net.TestFramework/Util/TestSecurityManager.cs
@@ -51,19 +51,19 @@ namespace Lucene.Net.Util
/// <exception cref="SecurityException"> if the caller of this method is not the test runner itself. </exception>
public override void CheckExit(int status)
{
- AccessController.doPrivileged(new PrivilegedActionAnonymousInnerClassHelper(this, status));
+ AccessController.doPrivileged(new PrivilegedActionAnonymousClass(this, status));
// we passed the stack check, delegate to super, so default policy can still deny permission:
base.CheckExit(status);
}
- private class PrivilegedActionAnonymousInnerClassHelper : PrivilegedAction<Void>
+ private class PrivilegedActionAnonymousClass : PrivilegedAction<Void>
{
private readonly TestSecurityManager OuterInstance;
private int Status;
- public PrivilegedActionAnonymousInnerClassHelper(TestSecurityManager outerInstance, int status)
+ public PrivilegedActionAnonymousClass(TestSecurityManager outerInstance, int status)
{
this.OuterInstance = outerInstance;
this.Status = status;
diff --git a/src/Lucene.Net.TestFramework/Util/TestUtil.cs b/src/Lucene.Net.TestFramework/Util/TestUtil.cs
index eb8728a..1dcc4ad 100644
--- a/src/Lucene.Net.TestFramework/Util/TestUtil.cs
+++ b/src/Lucene.Net.TestFramework/Util/TestUtil.cs
@@ -876,14 +876,14 @@ namespace Lucene.Net.Util
{
Console.WriteLine("forcing postings format to:" + format);
}
- return new Lucene46CodecAnonymousInnerClassHelper(format);
+ return new Lucene46CodecAnonymousClass(format);
}
- private class Lucene46CodecAnonymousInnerClassHelper : Lucene46Codec
+ private class Lucene46CodecAnonymousClass : Lucene46Codec
{
private readonly PostingsFormat format;
- public Lucene46CodecAnonymousInnerClassHelper(PostingsFormat format)
+ public Lucene46CodecAnonymousClass(PostingsFormat format)
{
this.format = format;
}
@@ -908,14 +908,14 @@ namespace Lucene.Net.Util
{
Console.WriteLine("forcing docvalues format to:" + format);
}
- return new Lucene46CodecAnonymousInnerClassHelper2(format);
+ return new Lucene46CodecAnonymousClass2(format);
}
- private class Lucene46CodecAnonymousInnerClassHelper2 : Lucene46Codec
+ private class Lucene46CodecAnonymousClass2 : Lucene46Codec
{
private readonly DocValuesFormat format;
- public Lucene46CodecAnonymousInnerClassHelper2(DocValuesFormat format)
+ public Lucene46CodecAnonymousClass2(DocValuesFormat format)
{
this.format = format;
}
@@ -1024,15 +1024,15 @@ namespace Lucene.Net.Util
public static void AssertAttributeReflection(Attribute att, IDictionary<string, object> reflectedValues)
{
IDictionary<string, object> map = new JCG.Dictionary<string, object>();
- att.ReflectWith(new AttributeReflectorAnonymousInnerClassHelper(map));
+ att.ReflectWith(new AttributeReflectorAnonymousClass(map));
Assert.AreEqual(reflectedValues, map, aggressive: false, "Reflection does not produce same map");
}
- private class AttributeReflectorAnonymousInnerClassHelper : IAttributeReflector
+ private class AttributeReflectorAnonymousClass : IAttributeReflector
{
private readonly IDictionary<string, object> map;
- public AttributeReflectorAnonymousInnerClassHelper(IDictionary<string, object> map)
+ public AttributeReflectorAnonymousClass(IDictionary<string, object> map)
{
this.map = map;
}
@@ -1278,7 +1278,7 @@ namespace Lucene.Net.Util
{
case 5:
case 4:
- return new RandomAccessFilterStrategyAnonymousInnerClassHelper();
+ return new RandomAccessFilterStrategyAnonymousClass();
case 3:
return FilteredQuery.RANDOM_ACCESS_FILTER_STRATEGY;
@@ -1297,7 +1297,7 @@ namespace Lucene.Net.Util
}
}
- private class RandomAccessFilterStrategyAnonymousInnerClassHelper : FilteredQuery.RandomAccessFilterStrategy
+ private class RandomAccessFilterStrategyAnonymousClass : FilteredQuery.RandomAccessFilterStrategy
{
protected override bool UseRandomAccess(IBits bits, int firstFilterDoc)
{
diff --git a/src/Lucene.Net.Tests.Analysis.Common/Analysis/Core/TestBugInSomething.cs b/src/Lucene.Net.Tests.Analysis.Common/Analysis/Core/TestBugInSomething.cs
index e9365b8..dab7c1b 100644
--- a/src/Lucene.Net.Tests.Analysis.Common/Analysis/Core/TestBugInSomething.cs
+++ b/src/Lucene.Net.Tests.Analysis.Common/Analysis/Core/TestBugInSomething.cs
@@ -61,11 +61,11 @@ namespace Lucene.Net.Analysis.Core
CheckAnalysisConsistency(Random, a, false, "wmgddzunizdomqyj");
}
- internal CharFilter wrappedStream = new CharFilterAnonymousInnerClassHelper(new StringReader("bogus"));
+ internal CharFilter wrappedStream = new CharFilterAnonymousClass(new StringReader("bogus"));
- private sealed class CharFilterAnonymousInnerClassHelper : CharFilter
+ private sealed class CharFilterAnonymousClass : CharFilter
{
- public CharFilterAnonymousInnerClassHelper(StringReader java) : base(java)
+ public CharFilterAnonymousClass(StringReader java) : base(java)
{
}
diff --git a/src/Lucene.Net.Tests.Analysis.Common/Analysis/Core/TestFactories.cs b/src/Lucene.Net.Tests.Analysis.Common/Analysis/Core/TestFactories.cs
index 072d41d..43b0365 100644
--- a/src/Lucene.Net.Tests.Analysis.Common/Analysis/Core/TestFactories.cs
+++ b/src/Lucene.Net.Tests.Analysis.Common/Analysis/Core/TestFactories.cs
@@ -189,11 +189,11 @@ namespace Lucene.Net.Analysis.Core
}
// some silly classes just so we can use checkRandomData
- private readonly TokenizerFactory assertingTokenizer = new AnonymousInnerClassHelperTokenizerFactory(new Dictionary<string, string>());
+ private readonly TokenizerFactory assertingTokenizer = new TokenizerFactoryAnonymousClass(new Dictionary<string, string>());
- private sealed class AnonymousInnerClassHelperTokenizerFactory : TokenizerFactory
+ private sealed class TokenizerFactoryAnonymousClass : TokenizerFactory
{
- public AnonymousInnerClassHelperTokenizerFactory(IDictionary<string, string> java) : base(java)
+ public TokenizerFactoryAnonymousClass(IDictionary<string, string> java) : base(java)
{
}
diff --git a/src/Lucene.Net.Tests.Analysis.Common/Analysis/Core/TestRandomChains.cs b/src/Lucene.Net.Tests.Analysis.Common/Analysis/Core/TestRandomChains.cs
index 0d67b47..656dba5 100644
--- a/src/Lucene.Net.Tests.Analysis.Common/Analysis/Core/TestRandomChains.cs
+++ b/src/Lucene.Net.Tests.Analysis.Common/Analysis/Core/TestRandomChains.cs
@@ -68,11 +68,11 @@ namespace Lucene.Net.Analysis.Core
bool Apply(T o);
}
- private static readonly IPredicate<object[]> ALWAYS = new PredicateAnonymousInnerClassHelper();
+ private static readonly IPredicate<object[]> ALWAYS = new PredicateAnonymousClass();
- private class PredicateAnonymousInnerClassHelper : IPredicate<object[]>
+ private class PredicateAnonymousClass : IPredicate<object[]>
{
- public PredicateAnonymousInnerClassHelper()
+ public PredicateAnonymousClass()
{
}
@@ -95,9 +95,9 @@ namespace Lucene.Net.Analysis.Core
try
{
brokenConstructors[typeof(LimitTokenCountFilter).GetConstructor(new Type[] { typeof(TokenStream), typeof(int) })] = ALWAYS;
- brokenConstructors[typeof(LimitTokenCountFilter).GetConstructor(new Type[] { typeof(TokenStream), typeof(int), typeof(bool) })] = new PredicateAnonymousInnerClassHelper2();
+ brokenConstructors[typeof(LimitTokenCountFilter).GetConstructor(new Type[] { typeof(TokenStream), typeof(int), typeof(bool) })] = new PredicateAnonymousClass2();
brokenConstructors[typeof(LimitTokenPositionFilter).GetConstructor(new Type[] { typeof(TokenStream), typeof(int) })] = ALWAYS;
- brokenConstructors[typeof(LimitTokenPositionFilter).GetConstructor(new Type[] { typeof(TokenStream), typeof(int), typeof(bool) })] = new PredicateAnonymousInnerClassHelper3();
+ brokenConstructors[typeof(LimitTokenPositionFilter).GetConstructor(new Type[] { typeof(TokenStream), typeof(int), typeof(bool) })] = new PredicateAnonymousClass3();
foreach (Type c in new Type[] {
// TODO: can we promote some of these to be only
// offsets offenders?
@@ -166,9 +166,9 @@ namespace Lucene.Net.Analysis.Core
allowedCharFilterArgs.Add(typeof(TextReader));
}
- private class PredicateAnonymousInnerClassHelper2 : IPredicate<object[]>
+ private class PredicateAnonymousClass2 : IPredicate<object[]>
{
- public PredicateAnonymousInnerClassHelper2()
+ public PredicateAnonymousClass2()
{
}
@@ -179,9 +179,9 @@ namespace Lucene.Net.Analysis.Core
}
}
- private class PredicateAnonymousInnerClassHelper3 : IPredicate<object[]>
+ private class PredicateAnonymousClass3 : IPredicate<object[]>
{
- public PredicateAnonymousInnerClassHelper3()
+ public PredicateAnonymousClass3()
{
}
diff --git a/src/Lucene.Net.Tests.Analysis.Common/Analysis/Miscellaneous/TestRemoveDuplicatesTokenFilter.cs b/src/Lucene.Net.Tests.Analysis.Common/Analysis/Miscellaneous/TestRemoveDuplicatesTokenFilter.cs
index e903892..e01e9ea 100644
--- a/src/Lucene.Net.Tests.Analysis.Common/Analysis/Miscellaneous/TestRemoveDuplicatesTokenFilter.cs
+++ b/src/Lucene.Net.Tests.Analysis.Common/Analysis/Miscellaneous/TestRemoveDuplicatesTokenFilter.cs
@@ -45,16 +45,16 @@ namespace Lucene.Net.Analysis.Miscellaneous
public virtual void TestDups(string expected, params Token[] tokens)
{
IEnumerator<Token> toks = ((IEnumerable<Token>)tokens).GetEnumerator();
- TokenStream ts = new RemoveDuplicatesTokenFilter((new TokenStreamAnonymousInnerClassHelper(toks)));
+ TokenStream ts = new RemoveDuplicatesTokenFilter((new TokenStreamAnonymousClass(toks)));
AssertTokenStreamContents(ts, Regex.Split(expected, "\\s").TrimEnd());
}
- private sealed class TokenStreamAnonymousInnerClassHelper : TokenStream
+ private sealed class TokenStreamAnonymousClass : TokenStream
{
private readonly IEnumerator<Token> toks;
- public TokenStreamAnonymousInnerClassHelper(IEnumerator<Token> toks)
+ public TokenStreamAnonymousClass(IEnumerator<Token> toks)
{
this.toks = toks;
termAtt = AddAttribute<ICharTermAttribute>();
diff --git a/src/Lucene.Net.Tests.Analysis.Common/Analysis/NGram/NGramTokenizerTest.cs b/src/Lucene.Net.Tests.Analysis.Common/Analysis/NGram/NGramTokenizerTest.cs
index 9cbe369..42c7669 100644
--- a/src/Lucene.Net.Tests.Analysis.Common/Analysis/NGram/NGramTokenizerTest.cs
+++ b/src/Lucene.Net.Tests.Analysis.Common/Analysis/NGram/NGramTokenizerTest.cs
@@ -183,7 +183,7 @@ namespace Lucene.Net.Analysis.NGram
{
offsets[i + 1] = offsets[i] + Character.CharCount(codePoints[i]);
}
- TokenStream grams = new NGramTokenizerAnonymousInnerClassHelper(TEST_VERSION_CURRENT, new StringReader(s), minGram, maxGram, edgesOnly, nonTokenChars);
+ TokenStream grams = new NGramTokenizerAnonymousClass(TEST_VERSION_CURRENT, new StringReader(s), minGram, maxGram, edgesOnly, nonTokenChars);
ICharTermAttribute termAtt = grams.AddAttribute<ICharTermAttribute>();
IPositionIncrementAttribute posIncAtt = grams.AddAttribute<IPositionIncrementAttribute>();
IPositionLengthAttribute posLenAtt = grams.AddAttribute<IPositionLengthAttribute>();
@@ -221,11 +221,11 @@ namespace Lucene.Net.Analysis.NGram
assertEquals(s.Length, offsetAtt.EndOffset);
}
- private sealed class NGramTokenizerAnonymousInnerClassHelper : NGramTokenizer
+ private sealed class NGramTokenizerAnonymousClass : NGramTokenizer
{
private readonly string nonTokenChars;
- public NGramTokenizerAnonymousInnerClassHelper(LuceneVersion TEST_VERSION_CURRENT, StringReader java, int minGram, int maxGram, bool edgesOnly, string nonTokenChars)
+ public NGramTokenizerAnonymousClass(LuceneVersion TEST_VERSION_CURRENT, StringReader java, int minGram, int maxGram, bool edgesOnly, string nonTokenChars)
: base(TEST_VERSION_CURRENT, java, minGram, maxGram, edgesOnly)
{
this.nonTokenChars = nonTokenChars;
diff --git a/src/Lucene.Net.Tests.Analysis.Common/Analysis/Sinks/TestTeeSinkTokenFilter.cs b/src/Lucene.Net.Tests.Analysis.Common/Analysis/Sinks/TestTeeSinkTokenFilter.cs
index 2d52d22..33502a8 100644
--- a/src/Lucene.Net.Tests.Analysis.Common/Analysis/Sinks/TestTeeSinkTokenFilter.cs
+++ b/src/Lucene.Net.Tests.Analysis.Common/Analysis/Sinks/TestTeeSinkTokenFilter.cs
@@ -59,9 +59,9 @@ namespace Lucene.Net.Analysis.Sinks
}
}
- internal static readonly TeeSinkTokenFilter.SinkFilter theFilter = new SinkFilterAnonymousInnerClassHelper();
+ internal static readonly TeeSinkTokenFilter.SinkFilter theFilter = new SinkFilterAnonymousClass();
- private sealed class SinkFilterAnonymousInnerClassHelper : TeeSinkTokenFilter.SinkFilter
+ private sealed class SinkFilterAnonymousClass : TeeSinkTokenFilter.SinkFilter
{
public override bool Accept(AttributeSource a)
{
@@ -70,9 +70,9 @@ namespace Lucene.Net.Analysis.Sinks
}
}
- internal static readonly TeeSinkTokenFilter.SinkFilter dogFilter = new SinkFilterAnonymousInnerClassHelper2();
+ internal static readonly TeeSinkTokenFilter.SinkFilter dogFilter = new SinkFilterAnonymousClass2();
- private sealed class SinkFilterAnonymousInnerClassHelper2 : TeeSinkTokenFilter.SinkFilter
+ private sealed class SinkFilterAnonymousClass2 : TeeSinkTokenFilter.SinkFilter
{
public override bool Accept(AttributeSource a)
{
diff --git a/src/Lucene.Net.Tests.Analysis.Common/Analysis/Synonym/TestSynonymMap.cs b/src/Lucene.Net.Tests.Analysis.Common/Analysis/Synonym/TestSynonymMap.cs
index 46f2482..844374f 100644
--- a/src/Lucene.Net.Tests.Analysis.Common/Analysis/Synonym/TestSynonymMap.cs
+++ b/src/Lucene.Net.Tests.Analysis.Common/Analysis/Synonym/TestSynonymMap.cs
@@ -280,7 +280,7 @@ namespace Lucene.Net.Analysis.Synonym
IDictionary<string, string> args = new Dictionary<string, string>();
args["synonyms"] = "something.txt";
SlowSynonymFilterFactory ff = new SlowSynonymFilterFactory(args);
- ff.Inform(new ResourceLoaderAnonymousInnerClassHelper());
+ ff.Inform(new ResourceLoaderAnonymousClass());
SlowSynonymMap synMap = ff.SynonymMap;
assertEquals(2, synMap.Submap.size());
@@ -290,7 +290,7 @@ namespace Lucene.Net.Analysis.Synonym
AssertTokIncludes(synMap, "b", "b");
}
- internal sealed class ResourceLoaderAnonymousInnerClassHelper : IResourceLoader
+ internal sealed class ResourceLoaderAnonymousClass : IResourceLoader
{
public T NewInstance<T>(string cname)
{
diff --git a/src/Lucene.Net.Tests.Analysis.Common/Analysis/Util/TestAnalysisSPILoader.cs b/src/Lucene.Net.Tests.Analysis.Common/Analysis/Util/TestAnalysisSPILoader.cs
index 2e9089a..b782958 100644
--- a/src/Lucene.Net.Tests.Analysis.Common/Analysis/Util/TestAnalysisSPILoader.cs
+++ b/src/Lucene.Net.Tests.Analysis.Common/Analysis/Util/TestAnalysisSPILoader.cs
@@ -30,12 +30,12 @@ namespace Lucene.Net.Analysis.Util
private IDictionary<string, string> VersionArgOnly()
{
- return new HashMapAnonymousInnerClassHelper();
+ return new HashMapAnonymousClass();
}
- private sealed class HashMapAnonymousInnerClassHelper : Dictionary<string, string>
+ private sealed class HashMapAnonymousClass : Dictionary<string, string>
{
- public HashMapAnonymousInnerClassHelper()
+ public HashMapAnonymousClass()
{
this["luceneMatchVersion"] = TEST_VERSION_CURRENT.ToString();
}
diff --git a/src/Lucene.Net.Tests.Analysis.Common/Analysis/Util/TestBufferedCharFilter.cs b/src/Lucene.Net.Tests.Analysis.Common/Analysis/Util/TestBufferedCharFilter.cs
index cc9cd0e..309553d 100644
--- a/src/Lucene.Net.Tests.Analysis.Common/Analysis/Util/TestBufferedCharFilter.cs
+++ b/src/Lucene.Net.Tests.Analysis.Common/Analysis/Util/TestBufferedCharFilter.cs
@@ -261,14 +261,14 @@ namespace Lucene.Net.Analysis.Util
assertTrue(new BufferedCharFilter(new StringReader(new string(new char[5], 1, 0)), 2).Read() == -1);
}
- private sealed class ReaderAnonymousInnerClassHelper : CharFilter
+ private sealed class ReaderAnonymousClass : CharFilter
{
private const int SIZE = 2;
private int pos = 0;
private readonly char[] contents = new char[SIZE];
- public ReaderAnonymousInnerClassHelper()
+ public ReaderAnonymousClass()
: base(null)
{ }
@@ -435,7 +435,7 @@ namespace Lucene.Net.Analysis.Util
fail("Exception during read test");
}
- BufferedCharFilter bufin = new BufferedCharFilter(new ReaderAnonymousInnerClassHelper());
+ BufferedCharFilter bufin = new BufferedCharFilter(new ReaderAnonymousClass());
//BufferedCharFilter bufin = new BufferedCharFilter(new Reader() {
// int size = 2, pos = 0;
diff --git a/src/Lucene.Net.Tests.Analysis.Common/Analysis/Util/TestCharTokenizers.cs b/src/Lucene.Net.Tests.Analysis.Common/Analysis/Util/TestCharTokenizers.cs
index da3e608..4493c32 100644
--- a/src/Lucene.Net.Tests.Analysis.Common/Analysis/Util/TestCharTokenizers.cs
+++ b/src/Lucene.Net.Tests.Analysis.Common/Analysis/Util/TestCharTokenizers.cs
@@ -121,7 +121,7 @@ namespace Lucene.Net.Analysis.Util
[Test]
public virtual void TestCrossPlaneNormalization()
{
- var analyzer = new AnalyzerAnonymousInnerClassHelper();
+ var analyzer = new AnalyzerAnonymousClass();
var num = 1000 * RandomMultiplier;
for (var i = 0; i < num; i++)
{
@@ -151,17 +151,17 @@ namespace Lucene.Net.Analysis.Util
CheckRandomData(Random, analyzer, num);
}
- private sealed class AnalyzerAnonymousInnerClassHelper : Analyzer
+ private sealed class AnalyzerAnonymousClass : Analyzer
{
protected internal override TokenStreamComponents CreateComponents(string fieldName, TextReader reader)
{
- Tokenizer tokenizer = new LetterTokenizerAnonymousInnerClassHelper(TEST_VERSION_CURRENT, reader);
+ Tokenizer tokenizer = new LetterTokenizerAnonymousClass(TEST_VERSION_CURRENT, reader);
return new TokenStreamComponents(tokenizer, tokenizer);
}
- private sealed class LetterTokenizerAnonymousInnerClassHelper : LetterTokenizer
+ private sealed class LetterTokenizerAnonymousClass : LetterTokenizer
{
- public LetterTokenizerAnonymousInnerClassHelper(LuceneVersion TEST_VERSION_CURRENT, TextReader reader)
+ public LetterTokenizerAnonymousClass(LuceneVersion TEST_VERSION_CURRENT, TextReader reader)
: base(TEST_VERSION_CURRENT, reader)
{
}
@@ -184,7 +184,7 @@ namespace Lucene.Net.Analysis.Util
[Test]
public virtual void TestCrossPlaneNormalization2()
{
- var analyzer = new AnalyzerAnonymousInnerClassHelper2();
+ var analyzer = new AnalyzerAnonymousClass2();
var num = 1000 * RandomMultiplier;
for (var i = 0; i < num; i++)
{
@@ -214,17 +214,17 @@ namespace Lucene.Net.Analysis.Util
CheckRandomData(Random, analyzer, num);
}
- private sealed class AnalyzerAnonymousInnerClassHelper2 : Analyzer
+ private sealed class AnalyzerAnonymousClass2 : Analyzer
{
protected internal override TokenStreamComponents CreateComponents(string fieldName, TextReader reader)
{
- Tokenizer tokenizer = new LetterTokenizerAnonymousInnerClassHelper2(TEST_VERSION_CURRENT, reader);
+ Tokenizer tokenizer = new LetterTokenizerAnonymousClass2(TEST_VERSION_CURRENT, reader);
return new TokenStreamComponents(tokenizer, tokenizer);
}
- private sealed class LetterTokenizerAnonymousInnerClassHelper2 : LetterTokenizer
+ private sealed class LetterTokenizerAnonymousClass2 : LetterTokenizer
{
- public LetterTokenizerAnonymousInnerClassHelper2(LuceneVersion TEST_VERSION_CURRENT, TextReader reader)
+ public LetterTokenizerAnonymousClass2(LuceneVersion TEST_VERSION_CURRENT, TextReader reader)
: base(TEST_VERSION_CURRENT, reader)
{
}
@@ -252,15 +252,15 @@ namespace Lucene.Net.Analysis.Util
[LuceneNetSpecific]
public virtual void TestSurrogates()
{
- var analyzer = new AnalyzerAnonymousInnerClassHelper3();
+ var analyzer = new AnalyzerAnonymousClass3();
AssertAnalyzesTo(analyzer, "bar 123" + (char)55404 + (char)56321 + "34 5te 987", new string[] { "123𫀁34", "5", "987" });
AssertAnalyzesTo(analyzer, "787 " + (char)55297 + (char)56388 + "6" + (char)55404 + (char)56321 + " art true 734", new string[] { "787", "𐑄6𫀁", "734" });
}
- private sealed class AnalyzerAnonymousInnerClassHelper3 : Analyzer
+ private sealed class AnalyzerAnonymousClass3 : Analyzer
{
- public AnalyzerAnonymousInnerClassHelper3()
+ public AnalyzerAnonymousClass3()
{ }
protected internal override TokenStreamComponents CreateComponents(string fieldName, TextReader reader)
diff --git a/src/Lucene.Net.Tests.Analysis.ICU/Analysis/Icu/Segmentation/TestICUTokenizer.cs b/src/Lucene.Net.Tests.Analysis.ICU/Analysis/Icu/Segmentation/TestICUTokenizer.cs
index 73c21ac..23b6f21 100644
--- a/src/Lucene.Net.Tests.Analysis.ICU/Analysis/Icu/Segmentation/TestICUTokenizer.cs
+++ b/src/Lucene.Net.Tests.Analysis.ICU/Analysis/Icu/Segmentation/TestICUTokenizer.cs
@@ -351,11 +351,11 @@ namespace Lucene.Net.Analysis.Icu.Segmentation
ts.End();
}
- private class ThreadAnonymousHelper : ThreadJob
+ private class ThreadAnonymousClass : ThreadJob
{
private readonly CountdownEvent startingGun;
- public ThreadAnonymousHelper(CountdownEvent startingGun)
+ public ThreadAnonymousClass(CountdownEvent startingGun)
{
this.startingGun = startingGun;
}
@@ -399,10 +399,10 @@ namespace Lucene.Net.Analysis.Icu.Segmentation
{
int numThreads = 8;
CountdownEvent startingGun = new CountdownEvent(1);
- ThreadAnonymousHelper[] threads = new ThreadAnonymousHelper[numThreads];
+ ThreadAnonymousClass[] threads = new ThreadAnonymousClass[numThreads];
for (int i = 0; i < threads.Length; i++)
{
- threads[i] = new ThreadAnonymousHelper(startingGun);
+ threads[i] = new ThreadAnonymousClass(startingGun);
threads[i].Start();
}
diff --git a/src/Lucene.Net.Tests.Benchmark/ByTask/Tasks/CountingHighlighterTestTask.cs b/src/Lucene.Net.Tests.Benchmark/ByTask/Tasks/CountingHighlighterTestTask.cs
index 678339f..2aea5df 100644
--- a/src/Lucene.Net.Tests.Benchmark/ByTask/Tasks/CountingHighlighterTestTask.cs
+++ b/src/Lucene.Net.Tests.Benchmark/ByTask/Tasks/CountingHighlighterTestTask.cs
@@ -46,11 +46,11 @@ namespace Lucene.Net.Benchmarks.ByTask.Tasks
return document;
}
- private class BenchmarkHighlighterAnonymousHelper : BenchmarkHighlighter
+ private class BenchmarkHighlighterAnonymousClass : BenchmarkHighlighter
{
private readonly CountingHighlighterTestTask outerInstance;
private readonly Highlighter highlighter;
- public BenchmarkHighlighterAnonymousHelper(CountingHighlighterTestTask outerInstance, Highlighter highlighter)
+ public BenchmarkHighlighterAnonymousClass(CountingHighlighterTestTask outerInstance, Highlighter highlighter)
{
this.outerInstance = outerInstance;
this.highlighter = highlighter;
@@ -68,7 +68,7 @@ namespace Lucene.Net.Benchmarks.ByTask.Tasks
protected override BenchmarkHighlighter GetBenchmarkHighlighter(Query q)
{
m_highlighter = new Highlighter(new SimpleHTMLFormatter(), new QueryScorer(q));
- return new BenchmarkHighlighterAnonymousHelper(this, m_highlighter);
+ return new BenchmarkHighlighterAnonymousClass(this, m_highlighter);
// return new BenchmarkHighlighter() {
// @Override
// public int doHighlight(IndexReader reader, int doc, String field, Document document, Analyzer analyzer, String text)
diff --git a/src/Lucene.Net.Tests.Benchmark/ByTask/Tasks/WriteLineDocTaskTest.cs b/src/Lucene.Net.Tests.Benchmark/ByTask/Tasks/WriteLineDocTaskTest.cs
index b937246..9e994aa 100644
--- a/src/Lucene.Net.Tests.Benchmark/ByTask/Tasks/WriteLineDocTaskTest.cs
+++ b/src/Lucene.Net.Tests.Benchmark/ByTask/Tasks/WriteLineDocTaskTest.cs
@@ -368,10 +368,10 @@ namespace Lucene.Net.Benchmarks.ByTask.Tasks
br.Dispose();
}
}
- private class ThreadAnonymousHelper : ThreadJob
+ private class ThreadAnonymousClass : ThreadJob
{
private readonly WriteLineDocTask wldt;
- public ThreadAnonymousHelper(string name, WriteLineDocTask wldt)
+ public ThreadAnonymousClass(string name, WriteLineDocTask wldt)
: base(name)
{
this.IsDebug = true;
@@ -401,7 +401,7 @@ namespace Lucene.Net.Benchmarks.ByTask.Tasks
{
for (int i = 0; i < threads.Length; i++)
{
- threads[i] = new ThreadAnonymousHelper("t" + i, wldt);
+ threads[i] = new ThreadAnonymousClass("t" + i, wldt);
}
foreach (ThreadJob t in threads) t.Start();
diff --git a/src/Lucene.Net.Tests.Facet/Range/TestRangeFacetCounts.cs b/src/Lucene.Net.Tests.Facet/Range/TestRangeFacetCounts.cs
index cd742c5..be755e8 100644
--- a/src/Lucene.Net.Tests.Facet/Range/TestRangeFacetCounts.cs
+++ b/src/Lucene.Net.Tests.Facet/Range/TestRangeFacetCounts.cs
@@ -283,7 +283,7 @@ namespace Lucene.Net.Facet.Range
Console.WriteLine("TEST: searcher=" + s);
}
- DrillSideways ds = new DrillSidewaysAnonymousInnerClassHelper(this, s, config, tr);
+ DrillSideways ds = new DrillSidewaysAnonymousClass(this, s, config, tr);
// First search, no drill downs:
DrillDownQuery ddq = new DrillDownQuery(config);
@@ -316,11 +316,11 @@ namespace Lucene.Net.Facet.Range
IOUtils.Dispose(tw, tr, td, w, r, d);
}
- private class DrillSidewaysAnonymousInnerClassHelper : DrillSideways
+ private class DrillSidewaysAnonymousClass : DrillSideways
{
private readonly TestRangeFacetCounts outerInstance;
- public DrillSidewaysAnonymousInnerClassHelper(TestRangeFacetCounts outerInstance, IndexSearcher s, FacetsConfig config, TaxonomyReader tr)
+ public DrillSidewaysAnonymousClass(TestRangeFacetCounts outerInstance, IndexSearcher s, FacetsConfig config, TaxonomyReader tr)
: base(s, config, tr)
{
this.outerInstance = outerInstance;
@@ -1095,7 +1095,7 @@ namespace Lucene.Net.Facet.Range
// Test wants 3 docs in one segment:
writer.ForceMerge(1);
- var vs = new ValueSourceAnonymousInnerClassHelper(this, doc);
+ var vs = new ValueSourceAnonymousClass(this, doc);
FacetsConfig config = new FacetsConfig();
@@ -1119,7 +1119,7 @@ namespace Lucene.Net.Facet.Range
if (Random.NextBoolean())
{
// Sort of silly:
- fastMatchFilter = new CachingWrapperFilterAnonymousInnerClassHelper(this, new QueryWrapperFilter(new MatchAllDocsQuery()), filterWasUsed);
+ fastMatchFilter = new CachingWrapperFilterAnonymousClass(this, new QueryWrapperFilter(new MatchAllDocsQuery()), filterWasUsed);
}
else
{
@@ -1144,7 +1144,7 @@ namespace Lucene.Net.Facet.Range
Assert.AreEqual(1, s.Search(ddq, 10).TotalHits);
// Test drill-sideways after drill-down
- DrillSideways ds = new DrillSidewaysAnonymousInnerClassHelper2(this, s, config, (TaxonomyReader)null, vs, ranges, fastMatchFilter);
+ DrillSideways ds = new DrillSidewaysAnonymousClass2(this, s, config, (TaxonomyReader)null, vs, ranges, fastMatchFilter);
DrillSidewaysResult dsr = ds.Search(ddq, 10);
@@ -1155,13 +1155,13 @@ namespace Lucene.Net.Facet.Range
IOUtils.Dispose(r, writer, dir);
}
- private class ValueSourceAnonymousInnerClassHelper : ValueSource
+ private class ValueSourceAnonymousClass : ValueSource
{
private readonly TestRangeFacetCounts outerInstance;
private readonly Document doc;
- public ValueSourceAnonymousInnerClassHelper(TestRangeFacetCounts outerInstance, Document doc)
+ public ValueSourceAnonymousClass(TestRangeFacetCounts outerInstance, Document doc)
{
this.outerInstance = outerInstance;
this.doc = doc;
@@ -1169,14 +1169,14 @@ namespace Lucene.Net.Facet.Range
public override FunctionValues GetValues(IDictionary ignored, AtomicReaderContext ignored2)
{
- return new DoubleDocValuesAnonymousInnerClassHelper(this);
+ return new DoubleDocValuesAnonymousClass(this);
}
- private class DoubleDocValuesAnonymousInnerClassHelper : DoubleDocValues
+ private class DoubleDocValuesAnonymousClass : DoubleDocValues
{
- private readonly ValueSourceAnonymousInnerClassHelper outerInstance;
+ private readonly ValueSourceAnonymousClass outerInstance;
- public DoubleDocValuesAnonymousInnerClassHelper(ValueSourceAnonymousInnerClassHelper outerInstance)
+ public DoubleDocValuesAnonymousClass(ValueSourceAnonymousClass outerInstance)
: base(null)
{
this.outerInstance = outerInstance;
@@ -1205,13 +1205,13 @@ namespace Lucene.Net.Facet.Range
}
- private class CachingWrapperFilterAnonymousInnerClassHelper : CachingWrapperFilter
+ private class CachingWrapperFilterAnonymousClass : CachingWrapperFilter
{
private readonly TestRangeFacetCounts outerInstance;
private readonly AtomicBoolean filterWasUsed;
- public CachingWrapperFilterAnonymousInnerClassHelper(TestRangeFacetCounts outerInstance, QueryWrapperFilter org, AtomicBoolean filterWasUsed)
+ public CachingWrapperFilterAnonymousClass(TestRangeFacetCounts outerInstance, QueryWrapperFilter org, AtomicBoolean filterWasUsed)
: base(org)
{
this.outerInstance = outerInstance;
@@ -1227,7 +1227,7 @@ namespace Lucene.Net.Facet.Range
}
}
- private class DrillSidewaysAnonymousInnerClassHelper2 : DrillSideways
+ private class DrillSidewaysAnonymousClass2 : DrillSideways
{
private readonly TestRangeFacetCounts outerInstance;
@@ -1236,7 +1236,7 @@ namespace Lucene.Net.Facet.Range
private readonly Filter fastMatchFilter;
- public DrillSidewaysAnonymousInnerClassHelper2(TestRangeFacetCounts outerInstance, IndexSearcher indexSearcher, FacetsConfig facetsConfig, TaxonomyReader org, ValueSource valueSource, DoubleRange[] doubleRanges, Filter filter)
+ public DrillSidewaysAnonymousClass2(TestRangeFacetCounts outerInstance, IndexSearcher indexSearcher, FacetsConfig facetsConfig, TaxonomyReader org, ValueSource valueSource, DoubleRange[] doubleRanges, Filter filter)
: base(indexSearcher, facetsConfig, org)
{
this.outerInstance = outerInstance;
diff --git a/src/Lucene.Net.Tests.Facet/Taxonomy/Directory/TestAddTaxonomy.cs b/src/Lucene.Net.Tests.Facet/Taxonomy/Directory/TestAddTaxonomy.cs
index b778272..96b0892 100644
--- a/src/Lucene.Net.Tests.Facet/Taxonomy/Directory/TestAddTaxonomy.cs
+++ b/src/Lucene.Net.Tests.Facet/Taxonomy/Directory/TestAddTaxonomy.cs
@@ -47,7 +47,7 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
ThreadJob[] addThreads = new ThreadJob[4];
for (int j = 0; j < addThreads.Length; j++)
{
- addThreads[j] = new ThreadAnonymousInnerClassHelper(this, range, numCats, tw);
+ addThreads[j] = new ThreadAnonymousClass(this, range, numCats, tw);
}
foreach (ThreadJob t in addThreads)
@@ -72,7 +72,7 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
IOUtils.Dispose(dirs);
}
- private class ThreadAnonymousInnerClassHelper : ThreadJob
+ private class ThreadAnonymousClass : ThreadJob
{
private readonly TestAddTaxonomy outerInstance;
@@ -80,7 +80,7 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
private AtomicInt32 numCats;
private DirectoryTaxonomyWriter tw;
- public ThreadAnonymousInnerClassHelper(TestAddTaxonomy outerInstance, int range, AtomicInt32 numCats, DirectoryTaxonomyWriter tw)
+ public ThreadAnonymousClass(TestAddTaxonomy outerInstance, int range, AtomicInt32 numCats, DirectoryTaxonomyWriter tw)
{
this.outerInstance = outerInstance;
this.range = range;
@@ -250,7 +250,7 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
// again, in parallel -- in the end, no duplicate categories should exist.
Directory dest = NewDirectory();
var destTw = new DirectoryTaxonomyWriter(dest);
- var t = new ThreadAnonymousInnerClassHelper2(this, numCategories, destTw);
+ var t = new ThreadAnonymousClass2(this, numCategories, destTw);
t.Start();
IOrdinalMap map = new MemoryOrdinalMap();
@@ -274,14 +274,14 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
IOUtils.Dispose(src, dest);
}
- private class ThreadAnonymousInnerClassHelper2 : ThreadJob
+ private class ThreadAnonymousClass2 : ThreadJob
{
private readonly TestAddTaxonomy outerInstance;
private readonly int numCategories;
private readonly DirectoryTaxonomyWriter destTW;
- public ThreadAnonymousInnerClassHelper2(TestAddTaxonomy outerInstance, int numCategories, DirectoryTaxonomyWriter destTW)
+ public ThreadAnonymousClass2(TestAddTaxonomy outerInstance, int numCategories, DirectoryTaxonomyWriter destTW)
{
this.outerInstance = outerInstance;
this.numCategories = numCategories;
diff --git a/src/Lucene.Net.Tests.Facet/Taxonomy/Directory/TestConcurrentFacetedIndexing.cs b/src/Lucene.Net.Tests.Facet/Taxonomy/Directory/TestConcurrentFacetedIndexing.cs
index 3c83af3..9a2f56d 100644
--- a/src/Lucene.Net.Tests.Facet/Taxonomy/Directory/TestConcurrentFacetedIndexing.cs
+++ b/src/Lucene.Net.Tests.Facet/Taxonomy/Directory/TestConcurrentFacetedIndexing.cs
@@ -41,11 +41,11 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
// A No-Op ITaxonomyWriterCache which always discards all given categories, and
// always returns true in put(), to indicate some cache entries were cleared.
- private static ITaxonomyWriterCache NO_OP_CACHE = new TaxonomyWriterCacheAnonymousInnerClassHelper();
+ private static ITaxonomyWriterCache NO_OP_CACHE = new TaxonomyWriterCacheAnonymousClass();
- private class TaxonomyWriterCacheAnonymousInnerClassHelper : ITaxonomyWriterCache
+ private class TaxonomyWriterCacheAnonymousClass : ITaxonomyWriterCache
{
- public TaxonomyWriterCacheAnonymousInnerClassHelper()
+ public TaxonomyWriterCacheAnonymousClass()
{
}
@@ -119,7 +119,7 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
for (int i = 0; i < indexThreads.Length; i++)
{
- indexThreads[i] = new ThreadAnonymousInnerClassHelper(this, numDocs, values, iw, tw, config);
+ indexThreads[i] = new ThreadAnonymousClass(this, numDocs, values, iw, tw, config);
}
foreach (ThreadJob t in indexThreads)
@@ -165,7 +165,7 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
IOUtils.Dispose(tw, iw, tr, taxoDir, indexDir);
}
- private class ThreadAnonymousInnerClassHelper : ThreadJob
+ private class ThreadAnonymousClass : ThreadJob
{
private readonly TestConcurrentFacetedIndexing outerInstance;
@@ -175,7 +175,7 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
private readonly DirectoryTaxonomyWriter tw;
private readonly FacetsConfig config;
- public ThreadAnonymousInnerClassHelper(TestConcurrentFacetedIndexing outerInstance, AtomicInt32 numDocs, ConcurrentDictionary<string, string> values, IndexWriter iw, DirectoryTaxonomyWriter tw, FacetsConfig config)
+ public ThreadAnonymousClass(TestConcurrentFacetedIndexing outerInstance, AtomicInt32 numDocs, ConcurrentDictionary<string, string> values, IndexWriter iw, DirectoryTaxonomyWriter tw, FacetsConfig config)
{
this.outerInstance = outerInstance;
this.numDocs = numDocs;
diff --git a/src/Lucene.Net.Tests.Facet/Taxonomy/Directory/TestDirectoryTaxonomyReader.cs b/src/Lucene.Net.Tests.Facet/Taxonomy/Directory/TestDirectoryTaxonomyReader.cs
index 896c72f..e76dc9d 100644
--- a/src/Lucene.Net.Tests.Facet/Taxonomy/Directory/TestDirectoryTaxonomyReader.cs
+++ b/src/Lucene.Net.Tests.Facet/Taxonomy/Directory/TestDirectoryTaxonomyReader.cs
@@ -230,7 +230,7 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
// test openIfChanged() when the taxonomy contains many segments
Directory dir = NewDirectory();
- DirectoryTaxonomyWriter writer = new DirectoryTaxonomyWriterAnonymousInnerClassHelper(this, dir);
+ DirectoryTaxonomyWriter writer = new DirectoryTaxonomyWriterAnonymousClass(this, dir);
var reader = new DirectoryTaxonomyReader(writer);
int numRounds = Random.Next(10) + 10;
@@ -265,11 +265,11 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
dir.Dispose();
}
- private class DirectoryTaxonomyWriterAnonymousInnerClassHelper : DirectoryTaxonomyWriter
+ private class DirectoryTaxonomyWriterAnonymousClass : DirectoryTaxonomyWriter
{
private readonly TestDirectoryTaxonomyReader outerInstance;
- public DirectoryTaxonomyWriterAnonymousInnerClassHelper(TestDirectoryTaxonomyReader outerInstance, Directory dir)
+ public DirectoryTaxonomyWriterAnonymousClass(TestDirectoryTaxonomyReader outerInstance, Directory dir)
: base(dir)
{
this.outerInstance = outerInstance;
@@ -300,8 +300,8 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
// LUCENENET: We need to set the index writer before the constructor of the base class is called
// because the DirectoryTaxonomyWriter class constructor is the consumer of the OpenIndexWriter method.
// The only option seems to be to set it statically before creating the instance.
- DirectoryTaxonomyWriterAnonymousInnerClassHelper2.iw = iw;
- var writer = new DirectoryTaxonomyWriterAnonymousInnerClassHelper2(dir);
+ DirectoryTaxonomyWriterAnonymousClass2.iw = iw;
+ var writer = new DirectoryTaxonomyWriterAnonymousClass2(dir);
var reader = new DirectoryTaxonomyReader(writer);
Assert.AreEqual(1, reader.Count);
@@ -325,11 +325,11 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
dir.Dispose();
}
- private class DirectoryTaxonomyWriterAnonymousInnerClassHelper2 : DirectoryTaxonomyWriter
+ private class DirectoryTaxonomyWriterAnonymousClass2 : DirectoryTaxonomyWriter
{
internal static IndexWriter iw = null;
- public DirectoryTaxonomyWriterAnonymousInnerClassHelper2(Directory dir)
+ public DirectoryTaxonomyWriterAnonymousClass2(Directory dir)
: base(dir)
{
}
@@ -356,8 +356,8 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
// LUCENENET: We need to set the index writer before the constructor of the base class is called
// because the DirectoryTaxonomyWriter class constructor is the consumer of the OpenIndexWriter method.
// The only option seems to be to set it statically before creating the instance.
- DirectoryTaxonomyWriterAnonymousInnerClassHelper3.iw = iw;
- DirectoryTaxonomyWriter writer = new DirectoryTaxonomyWriterAnonymousInnerClassHelper3(dir);
+ DirectoryTaxonomyWriterAnonymousClass3.iw = iw;
+ DirectoryTaxonomyWriter writer = new DirectoryTaxonomyWriterAnonymousClass3(dir);
// add a category so that the following DTR open will cause a flush and
@@ -384,11 +384,11 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
dir.Dispose();
}
- private class DirectoryTaxonomyWriterAnonymousInnerClassHelper3 : DirectoryTaxonomyWriter
+ private class DirectoryTaxonomyWriterAnonymousClass3 : DirectoryTaxonomyWriter
{
internal static IndexWriter iw;
- public DirectoryTaxonomyWriterAnonymousInnerClassHelper3(Directory dir)
+ public DirectoryTaxonomyWriterAnonymousClass3(Directory dir)
: base(dir)
{
}
diff --git a/src/Lucene.Net.Tests.Facet/Taxonomy/Directory/TestDirectoryTaxonomyWriter.cs b/src/Lucene.Net.Tests.Facet/Taxonomy/Directory/TestDirectoryTaxonomyWriter.cs
index faab773..c6d6241 100644
--- a/src/Lucene.Net.Tests.Facet/Taxonomy/Directory/TestDirectoryTaxonomyWriter.cs
+++ b/src/Lucene.Net.Tests.Facet/Taxonomy/Directory/TestDirectoryTaxonomyWriter.cs
@@ -52,9 +52,9 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
// A No-Op ITaxonomyWriterCache which always discards all given categories, and
// always returns true in put(), to indicate some cache entries were cleared.
- private static readonly ITaxonomyWriterCache NO_OP_CACHE = new TaxonomyWriterCacheAnonymousInnerClassHelper();
+ private static readonly ITaxonomyWriterCache NO_OP_CACHE = new TaxonomyWriterCacheAnonymousClass();
- private class TaxonomyWriterCacheAnonymousInnerClassHelper : ITaxonomyWriterCache
+ private class TaxonomyWriterCacheAnonymousClass : ITaxonomyWriterCache
{
public virtual void Dispose()
{
@@ -296,7 +296,7 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
ThreadJob[] addThreads = new ThreadJob[AtLeast(4)];
for (int z = 0; z < addThreads.Length; z++)
{
- addThreads[z] = new ThreadAnonymousInnerClassHelper(range, numCats, values, tw);
+ addThreads[z] = new ThreadAnonymousClass(range, numCats, values, tw);
}
foreach (var t in addThreads)
@@ -344,14 +344,14 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
IOUtils.Dispose(dtr, dir);
}
- private class ThreadAnonymousInnerClassHelper : ThreadJob
+ private class ThreadAnonymousClass : ThreadJob
{
private readonly int range;
private readonly AtomicInt32 numCats;
private readonly ConcurrentDictionary<string, string> values;
private readonly DirectoryTaxonomyWriter tw;
- public ThreadAnonymousInnerClassHelper(int range, AtomicInt32 numCats, ConcurrentDictionary<string, string> values, DirectoryTaxonomyWriter tw)
+ public ThreadAnonymousClass(int range, AtomicInt32 numCats, ConcurrentDictionary<string, string> values, DirectoryTaxonomyWriter tw)
{
this.range = range;
this.numCats = numCats;
diff --git a/src/Lucene.Net.Tests.Facet/Taxonomy/TestCachedOrdinalsReader.cs b/src/Lucene.Net.Tests.Facet/Taxonomy/TestCachedOrdinalsReader.cs
index a1482d7..f23cd73 100644
--- a/src/Lucene.Net.Tests.Facet/Taxonomy/TestCachedOrdinalsReader.cs
+++ b/src/Lucene.Net.Tests.Facet/Taxonomy/TestCachedOrdinalsReader.cs
@@ -60,7 +60,7 @@ namespace Lucene.Net.Facet.Taxonomy
ThreadJob[] threads = new ThreadJob[3];
for (int i = 0; i < threads.Length; i++)
{
- threads[i] = new ThreadAnonymousInnerClassHelper(this, "CachedOrdsThread-" + i, reader, ordsReader);
+ threads[i] = new ThreadAnonymousClass(this, "CachedOrdsThread-" + i, reader, ordsReader);
}
long ramBytesUsed = 0;
@@ -81,14 +81,14 @@ namespace Lucene.Net.Facet.Taxonomy
IOUtils.Dispose(writer, taxoWriter, reader, indexDir, taxoDir);
}
- private class ThreadAnonymousInnerClassHelper : ThreadJob
+ private class ThreadAnonymousClass : ThreadJob
{
private readonly TestCachedOrdinalsReader outerInstance;
private readonly DirectoryReader reader;
private readonly CachedOrdinalsReader ordsReader;
- public ThreadAnonymousInnerClassHelper(TestCachedOrdinalsReader outerInstance, string threadName, DirectoryReader reader, CachedOrdinalsReader ordsReader)
+ public ThreadAnonymousClass(TestCachedOrdinalsReader outerInstance, string threadName, DirectoryReader reader, CachedOrdinalsReader ordsReader)
: base(threadName)
{
this.outerInstance = outerInstance;
diff --git a/src/Lucene.Net.Tests.Facet/Taxonomy/TestSearcherTaxonomyManager.cs b/src/Lucene.Net.Tests.Facet/Taxonomy/TestSearcherTaxonomyManager.cs
index 055f5c7..5fad91a 100644
--- a/src/Lucene.Net.Tests.Facet/Taxonomy/TestSearcherTaxonomyManager.cs
+++ b/src/Lucene.Net.Tests.Facet/Taxonomy/TestSearcherTaxonomyManager.cs
@@ -164,7 +164,7 @@ namespace Lucene.Net.Facet.Taxonomy
var mgr = new SearcherTaxonomyManager(w, true, null, tw);
- var reopener = new ThreadAnonymousInnerClassHelper(stop, mgr);
+ var reopener = new ThreadAnonymousClass(stop, mgr);
reopener.Name = "reopener";
reopener.Start();
@@ -215,12 +215,12 @@ namespace Lucene.Net.Facet.Taxonomy
IOUtils.Dispose(mgr, tw, w, taxoDir, dir);
}
- private class ThreadAnonymousInnerClassHelper : ThreadJob
+ private class ThreadAnonymousClass : ThreadJob
{
private readonly AtomicBoolean stop;
private readonly SearcherTaxonomyManager mgr;
- public ThreadAnonymousInnerClassHelper(AtomicBoolean stop, SearcherTaxonomyManager mgr)
+ public ThreadAnonymousClass(AtomicBoolean stop, SearcherTaxonomyManager mgr)
{
this.stop = stop;
this.mgr = mgr;
diff --git a/src/Lucene.Net.Tests.Facet/Taxonomy/TestTaxonomyCombined.cs b/src/Lucene.Net.Tests.Facet/Taxonomy/TestTaxonomyCombined.cs
index 31f64e9..2a8bc3e 100644
--- a/src/Lucene.Net.Tests.Facet/Taxonomy/TestTaxonomyCombined.cs
+++ b/src/Lucene.Net.Tests.Facet/Taxonomy/TestTaxonomyCombined.cs
@@ -848,7 +848,7 @@ namespace Lucene.Net.Facet.Taxonomy
Exception[] error = new Exception[] { null };
int[] retrieval = new int[] { 0 };
- var thread = new ThreadAnonymousInnerClassHelper(this, abPath, abOrd, abYoungChildBase1, abYoungChildBase2, retry, tr, stop, error, retrieval);
+ var thread = new ThreadAnonymousClass(this, abPath, abOrd, abYoungChildBase1, abYoungChildBase2, retry, tr, stop, error, retrieval);
thread.Start();
indexDir.SetSleepMillis(1); // some delay for refresh
@@ -865,7 +865,7 @@ namespace Lucene.Net.Facet.Taxonomy
tr.Dispose();
}
- private class ThreadAnonymousInnerClassHelper : ThreadJob
+ private class ThreadAnonymousClass : ThreadJob
{
private readonly TestTaxonomyCombined outerInstance;
@@ -879,7 +879,7 @@ namespace Lucene.Net.Facet.Taxonomy
private readonly Exception[] error;
private readonly int[] retrieval;
- public ThreadAnonymousInnerClassHelper(TestTaxonomyCombined outerInstance, FacetLabel abPath, int abOrd, int abYoungChildBase1, int abYoungChildBase2, int retry, DirectoryTaxonomyReader tr, AtomicBoolean stop, Exception[] error, int[] retrieval)
+ public ThreadAnonymousClass(TestTaxonomyCombined outerInstance, FacetLabel abPath, int abOrd, int abYoungChildBase1, int abYoungChildBase2, int retry, DirectoryTaxonomyReader tr, AtomicBoolean stop, Exception[] error, int[] retrieval)
: base("Child Arrays Verifier")
{
this.outerInstance = outerInstance;
diff --git a/src/Lucene.Net.Tests.Facet/Taxonomy/TestTaxonomyFacetCounts.cs b/src/Lucene.Net.Tests.Facet/Taxonomy/TestTaxonomyFacetCounts.cs
index 9f2ef49..afc86a5 100644
--- a/src/Lucene.Net.Tests.Facet/Taxonomy/TestTaxonomyFacetCounts.cs
+++ b/src/Lucene.Net.Tests.Facet/Taxonomy/TestTaxonomyFacetCounts.cs
@@ -298,7 +298,7 @@ namespace Lucene.Net.Facet.Taxonomy
Store.Directory dir = NewDirectory();
Store.Directory taxoDir = NewDirectory();
IndexWriterConfig iwc = NewIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(Random));
- iwc.SetSimilarity(new PerFieldSimilarityWrapperAnonymousInnerClassHelper(this));
+ iwc.SetSimilarity(new PerFieldSimilarityWrapperAnonymousClass(this));
ITaxonomyWriter taxoWriter = new DirectoryTaxonomyWriter(taxoDir, OpenMode.CREATE);
RandomIndexWriter writer = new RandomIndexWriter(Random, dir, iwc);
FacetsConfig config = new FacetsConfig();
@@ -310,11 +310,11 @@ namespace Lucene.Net.Facet.Taxonomy
IOUtils.Dispose(writer, taxoWriter, dir, taxoDir);
}
- private class PerFieldSimilarityWrapperAnonymousInnerClassHelper : PerFieldSimilarityWrapper
+ private class PerFieldSimilarityWrapperAnonymousClass : PerFieldSimilarityWrapper
{
private readonly TestTaxonomyFacetCounts outerInstance;
- public PerFieldSimilarityWrapperAnonymousInnerClassHelper(TestTaxonomyFacetCounts outerInstance)
+ public PerFieldSimilarityWrapperAnonymousClass(TestTaxonomyFacetCounts outerInstance)
{
this.outerInstance = outerInstance;
sim = new DefaultSimilarity();
diff --git a/src/Lucene.Net.Tests.Facet/Taxonomy/TestTaxonomyFacetSumValueSource.cs b/src/Lucene.Net.Tests.Facet/Taxonomy/TestTaxonomyFacetSumValueSource.cs
index d911db9..d56e83a 100644
--- a/src/Lucene.Net.Tests.Facet/Taxonomy/TestTaxonomyFacetSumValueSource.cs
+++ b/src/Lucene.Net.Tests.Facet/Taxonomy/TestTaxonomyFacetSumValueSource.cs
@@ -360,7 +360,7 @@ namespace Lucene.Net.Facet.Taxonomy
DirectoryReader r = DirectoryReader.Open(iw, true);
DirectoryTaxonomyReader taxoReader = new DirectoryTaxonomyReader(taxoWriter);
- ValueSource valueSource = new ValueSourceAnonymousInnerClassHelper(this);
+ ValueSource valueSource = new ValueSourceAnonymousClass(this);
FacetsCollector fc = new FacetsCollector(true);
// score documents by their 'price' field - makes asserting the correct counts for the categories easier
@@ -373,11 +373,11 @@ namespace Lucene.Net.Facet.Taxonomy
IOUtils.Dispose(taxoWriter, iw, taxoReader, taxoDir, r, indexDir);
}
- private class ValueSourceAnonymousInnerClassHelper : ValueSource
+ private class ValueSourceAnonymousClass : ValueSource
{
private readonly TestTaxonomyFacetSumValueSource outerInstance;
- public ValueSourceAnonymousInnerClassHelper(TestTaxonomyFacetSumValueSource outerInstance)
+ public ValueSourceAnonymousClass(TestTaxonomyFacetSumValueSource outerInstance)
{
this.outerInstance = outerInstance;
}
@@ -386,16 +386,16 @@ namespace Lucene.Net.Facet.Taxonomy
{
Scorer scorer = (Scorer)context["scorer"];
if (Debugging.AssertsEnabled) Debugging.Assert(scorer != null);
- return new DoubleDocValuesAnonymousInnerClassHelper(this, scorer);
+ return new DoubleDocValuesAnonymousClass(this, scorer);
}
- private class DoubleDocValuesAnonymousInnerClassHelper : DoubleDocValues
+ private class DoubleDocValuesAnonymousClass : DoubleDocValues
{
- private readonly ValueSourceAnonymousInnerClassHelper outerInstance;
+ private readonly ValueSourceAnonymousClass outerInstance;
private readonly Scorer scorer;
- public DoubleDocValuesAnonymousInnerClassHelper(ValueSourceAnonymousInnerClassHelper outerInstance, Scorer scorer)
+ public DoubleDocValuesAnonymousClass(ValueSourceAnonymousClass outerInstance, Scorer scorer)
: base(null) //todo: value source
{
this.outerInstance = outerInstance;
diff --git a/src/Lucene.Net.Tests.Facet/TestDrillSideways.cs b/src/Lucene.Net.Tests.Facet/TestDrillSideways.cs
index 3d9f235..a00f51b 100644
--- a/src/Lucene.Net.Tests.Facet/TestDrillSideways.cs
+++ b/src/Lucene.Net.Tests.Facet/TestDrillSideways.cs
@@ -753,7 +753,7 @@ namespace Lucene.Net.Facet
{
Console.WriteLine(" only-even filter");
}
- filter = new FilterAnonymousInnerClassHelper(this);
+ filter = new FilterAnonymousClass(this);
}
else
{
@@ -763,7 +763,7 @@ namespace Lucene.Net.Facet
// Verify docs are always collected in order. If we
// had an AssertingScorer it could catch it when
// Weight.scoresDocsOutOfOrder lies!:
- new DrillSideways(s, config, tr).Search(ddq, new CollectorAnonymousInnerClassHelper(this));
+ new DrillSideways(s, config, tr).Search(ddq, new CollectorAnonymousClass(this));
// Also separately verify that DS respects the
// scoreSubDocsAtOnce method, to ensure that all
@@ -774,7 +774,7 @@ namespace Lucene.Net.Facet
// drill-down values, because in that case it's
// easily possible for one of the DD terms to be on
// a future docID:
- new DrillSidewaysAnonymousInnerClassHelper(this, s, config, tr)
+ new DrillSidewaysAnonymousClass(this, s, config, tr)
.Search(ddq, new AssertingSubDocsAtOnceCollector());
}
@@ -788,7 +788,7 @@ namespace Lucene.Net.Facet
}
else
{
- ds = new DrillSidewaysAnonymousInnerClassHelper2(this, s, config, tr);
+ ds = new DrillSidewaysAnonymousClass2(this, s, config, tr);
}
// Retrieve all facets:
@@ -819,11 +819,11 @@ namespace Lucene.Net.Facet
IOUtils.Dispose(r, tr, w, tw, d, td);
}
- private class FilterAnonymousInnerClassHelper : Filter
+ private class FilterAnonymousClass : Filter
{
private readonly TestDrillSideways outerInstance;
- public FilterAnonymousInnerClassHelper(TestDrillSideways outerInstance)
+ public FilterAnonymousClass(TestDrillSideways outerInstance)
{
this.outerInstance = outerInstance;
}
@@ -844,11 +844,11 @@ namespace Lucene.Net.Facet
}
}
- private class CollectorAnonymousInnerClassHelper : ICollector
+ private class CollectorAnonymousClass : ICollector
{
private readonly TestDrillSideways outerInstance;
- public CollectorAnonymousInnerClassHelper(TestDrillSideways outerInstance)
+ public CollectorAnonymousClass(TestDrillSideways outerInstance)
{
this.outerInstance = outerInstance;
}
@@ -873,11 +873,11 @@ namespace Lucene.Net.Facet
public virtual bool AcceptsDocsOutOfOrder => false;
}
- private class DrillSidewaysAnonymousInnerClassHelper : DrillSideways
+ private class DrillSidewaysAnonymousClass : DrillSideways
{
private readonly TestDrillSideways outerInstance;
- public DrillSidewaysAnonymousInnerClassHelper(TestDrillSideways outerInstance, IndexSearcher s, FacetsConfig config, TaxonomyReader tr)
+ public DrillSidewaysAnonymousClass(TestDrillSideways outerInstance, IndexSearcher s, FacetsConfig config, TaxonomyReader tr)
: base(s, config, tr)
{
this.outerInstance = outerInstance;
@@ -886,11 +886,11 @@ namespace Lucene.Net.Facet
protected override bool ScoreSubDocsAtOnce => true;
}
- private class DrillSidewaysAnonymousInnerClassHelper2 : DrillSideways
+ private class DrillSidewaysAnonymousClass2 : DrillSideways
{
private readonly TestDrillSideways outerInstance;
- public DrillSidewaysAnonymousInnerClassHelper2(TestDrillSideways outerInstance, IndexSearcher s, FacetsConfig config, TaxonomyReader tr)
+ public DrillSidewaysAnonymousClass2(TestDrillSideways outerInstance, IndexSearcher s, FacetsConfig config, TaxonomyReader tr)
: base(s, config, tr)
{
this.outerInstance = outerInstance;
@@ -978,7 +978,7 @@ namespace Lucene.Net.Facet
// Naive (on purpose, to reduce bug in tester/gold):
// sort all ids, then return top N slice:
- new InPlaceMergeSorterAnonymousInnerClassHelper(this, counts, values, ids).Sort(0, ids.Length);
+ new InPlaceMergeSorterAnonymousClass(this, counts, values, ids).Sort(0, ids.Length);
if (topN > ids.Length)
{
@@ -1000,7 +1000,7 @@ namespace Lucene.Net.Facet
return topNIDs;
}
- private class InPlaceMergeSorterAnonymousInnerClassHelper : InPlaceMergeSorter
+ private class InPlaceMergeSorterAnonymousClass : InPlaceMergeSorter
{
private readonly TestDrillSideways outerInstance;
@@ -1008,7 +1008,7 @@ namespace Lucene.Net.Facet
private readonly string[] values;
private readonly int[] ids;
- public InPlaceMergeSorterAnonymousInnerClassHelper(TestDrillSideways outerInstance, int[] counts, string[] values, int[] ids)
+ public InPlaceMergeSorterAnonymousClass(TestDrillSideways outerInstance, int[] counts, string[] values, int[] ids)
{
this.outerInstance = outerInstance;
this.counts = counts;
diff --git a/src/Lucene.Net.Tests.Facet/TestFacetsConfig.cs b/src/Lucene.Net.Tests.Facet/TestFacetsConfig.cs
index a984aa3..105661c 100644
--- a/src/Lucene.Net.Tests.Facet/TestFacetsConfig.cs
+++ b/src/Lucene.Net.Tests.Facet/TestFacetsConfig.cs
@@ -103,16 +103,16 @@ namespace Lucene.Net.Facet
[Test]
public virtual void TestCustomDefault()
{
- FacetsConfig config = new FacetsConfigAnonymousInnerClassHelper(this);
+ FacetsConfig config = new FacetsConfigAnonymousClass(this);
Assert.IsTrue(config.GetDimConfig("foobar").IsHierarchical);
}
- private class FacetsConfigAnonymousInnerClassHelper : FacetsConfig
+ private class FacetsConfigAnonymousClass : FacetsConfig
{
private readonly TestFacetsConfig outerInstance;
- public FacetsConfigAnonymousInnerClassHelper(TestFacetsConfig outerInstance)
+ public FacetsConfigAnonymousClass(TestFacetsConfig outerInstance)
{
this.outerInstance = outerInstance;
}
diff --git a/src/Lucene.Net.Tests.Highlighter/Highlight/HighlighterPhraseTest.cs b/src/Lucene.Net.Tests.Highlighter/Highlight/HighlighterPhraseTest.cs
index 1485728..87c2fca 100644
--- a/src/Lucene.Net.Tests.Highlighter/Highlight/HighlighterPhraseTest.cs
+++ b/src/Lucene.Net.Tests.Highlighter/Highlight/HighlighterPhraseTest.cs
@@ -110,7 +110,7 @@ namespace Lucene.Net.Search.Highlight
new SpanTermQuery(new Term(FIELD, "fox")),
new SpanTermQuery(new Term(FIELD, "jumped")) }, 0, true);
FixedBitSet bitset = new FixedBitSet(indexReader.MaxDoc);
- indexSearcher.Search(phraseQuery, new ConcurrentSpanCollectorAnonymousHelper(this, bitset));
+ indexSearcher.Search(phraseQuery, new ConcurrentSpanCollectorAnonymousClass(this, bitset));
assertEquals(1, bitset.Cardinality());
int maxDoc = indexReader.MaxDoc;
@@ -135,11 +135,11 @@ namespace Lucene.Net.Search.Highlight
}
}
- internal class ConcurrentSpanCollectorAnonymousHelper : ICollector
+ internal class ConcurrentSpanCollectorAnonymousClass : ICollector
{
private readonly HighlighterPhraseTest outerInstance;
private readonly FixedBitSet bitset;
- public ConcurrentSpanCollectorAnonymousHelper(HighlighterPhraseTest outerInstance, FixedBitSet bitset)
+ public ConcurrentSpanCollectorAnonymousClass(HighlighterPhraseTest outerInstance, FixedBitSet bitset)
{
this.outerInstance = outerInstance;
this.bitset = bitset;
diff --git a/src/Lucene.Net.Tests.Highlighter/Highlight/HighlighterTest.cs b/src/Lucene.Net.Tests.Highlighter/Highlight/HighlighterTest.cs
index 66d2194..daf48d1 100644
--- a/src/Lucene.Net.Tests.Highlighter/Highlight/HighlighterTest.cs
+++ b/src/Lucene.Net.Tests.Highlighter/Highlight/HighlighterTest.cs
@@ -131,7 +131,7 @@ namespace Lucene.Net.Search.Highlight
assertEquals("<B>This</B> piece of text refers to Kennedy at the beginning then has a longer piece of text that is <B>very</B>", fragment);
}
- internal class TestHighlightUnknowQueryAnonymousHelper : Query
+ internal class TestHighlightUnknowQueryAnonymousClass : Query
{
public override Query Rewrite(IndexReader reader)
{
@@ -161,7 +161,7 @@ namespace Lucene.Net.Search.Highlight
[Test]
public void TestHighlightUnknowQueryAfterRewrite()
{
- Query query = new TestHighlightUnknowQueryAnonymousHelper();
+ Query query = new TestHighlightUnknowQueryAnonymousClass();
Analyzer analyzer = new MockAnalyzer(Random, MockTokenizer.SIMPLE, true);
@@ -1510,7 +1510,7 @@ namespace Lucene.Net.Search.Highlight
// for
// highlighting but scores a single fragment for selection
- Highlighter highlighter = new Highlighter(this, new SimpleHTMLEncoder(), new TestEncodingScorerAnonymousHelper(this));
+ Highlighter highlighter = new Highlighter(this, new SimpleHTMLEncoder(), new TestEncodingScorerAnonymousClass(this));
highlighter.TextFragmenter = (new SimpleFragmenter(2000));
TokenStream tokenStream = analyzer.GetTokenStream(FIELD_NAME, rawDocContent);
@@ -1543,11 +1543,11 @@ namespace Lucene.Net.Search.Highlight
assertEquals("XHTML Encoding should have worked:", rawDocContent, decodedSnippet);
}
- internal class TestEncodingScorerAnonymousHelper : IScorer
+ internal class TestEncodingScorerAnonymousClass : IScorer
{
private readonly HighlighterTest outerInstance;
- public TestEncodingScorerAnonymousHelper(HighlighterTest outerInstance)
+ public TestEncodingScorerAnonymousClass(HighlighterTest outerInstance)
{
this.outerInstance = outerInstance;
}
@@ -1624,13 +1624,13 @@ namespace Lucene.Net.Search.Highlight
protected TokenStream getTS2()
{
// String s = "Hi-Speed10 foo";
- return new TS2TokenStreamAnonymousHelper();
+ return new TS2TokenStreamAnonymousClass();
}
- protected sealed class TS2TokenStreamAnonymousHelper : TokenStream
+ protected sealed class TS2TokenStreamAnonymousClass : TokenStream
{
- public TS2TokenStreamAnonymousHelper()
+ public TS2TokenStreamAnonymousClass()
{
termAtt = AddAttribute<ICharTermAttribute>();
posIncrAtt = AddAttribute<IPositionIncrementAttribute>();
@@ -1687,12 +1687,12 @@ namespace Lucene.Net.Search.Highlight
protected TokenStream getTS2a()
{
// String s = "Hi-Speed10 foo";
- return new TS2aTokenStreamAnonymousHelper();
+ return new TS2aTokenStreamAnonymousClass();
}
- protected sealed class TS2aTokenStreamAnonymousHelper : TokenStream
+ protected sealed class TS2aTokenStreamAnonymousClass : TokenStream
{
- public TS2aTokenStreamAnonymousHelper()
+ public TS2aTokenStreamAnonymousClass()
{
termAtt = AddAttribute<ICharTermAttribute>();
posIncrAtt = AddAttribute<IPositionIncrementAttribute>();
diff --git a/src/Lucene.Net.Tests.Highlighter/Highlight/OffsetLimitTokenFilterTest.cs b/src/Lucene.Net.Tests.Highlighter/Highlight/OffsetLimitTokenFilterTest.cs
index 7269b53..aa9c029 100644
--- a/src/Lucene.Net.Tests.Highlighter/Highlight/OffsetLimitTokenFilterTest.cs
+++ b/src/Lucene.Net.Tests.Highlighter/Highlight/OffsetLimitTokenFilterTest.cs
@@ -51,10 +51,10 @@ namespace Lucene.Net.Search.Highlight
AssertTokenStreamContents(filter, new String[] {"short", "toolong",
"evenmuchlongertext"});
- CheckOneTerm(new AnalyzerAnonymousHelper(), "llenges", "llenges");
+ CheckOneTerm(new AnalyzerAnonymousClass(), "llenges", "llenges");
}
- internal class AnalyzerAnonymousHelper : Analyzer
+ internal class AnalyzerAnonymousClass : Analyzer
{
protected internal override TokenStreamComponents CreateComponents(string fieldName, TextReader reader)
{
diff --git a/src/Lucene.Net.Tests.Highlighter/VectorHighlight/FastVectorHighlighterTest.cs b/src/Lucene.Net.Tests.Highlighter/VectorHighlight/FastVectorHighlighterTest.cs
index 5b0320b..41eebac 100644
--- a/src/Lucene.Net.Tests.Highlighter/VectorHighlight/FastVectorHighlighterTest.cs
+++ b/src/Lucene.Net.Tests.Highlighter/VectorHighlight/FastVectorHighlighterTest.cs
@@ -596,7 +596,7 @@ namespace Lucene.Net.Search.VectorHighlight
token("red", 0, 0, 3)
), matched));
- Analyzer analyzer = new AnalyzerWrapperAnonymousHelper();
+ Analyzer analyzer = new AnalyzerWrapperAnonymousClass();
Directory dir = NewDirectory();
IndexWriter writer = new IndexWriter(dir, NewIndexWriterConfig(TEST_VERSION_CURRENT, analyzer));
@@ -642,12 +642,12 @@ namespace Lucene.Net.Search.VectorHighlight
dir.Dispose();
}
- internal class AnalyzerWrapperAnonymousHelper : AnalyzerWrapper
+ internal class AnalyzerWrapperAnonymousClass : AnalyzerWrapper
{
IDictionary<String, Analyzer> fieldAnalyzers = new JCG.SortedDictionary<String, Analyzer>(StringComparer.Ordinal);
#pragma warning disable 612, 618 // LUCENENET NOTE: Class calls obsolete (default) constructor
- public AnalyzerWrapperAnonymousHelper()
+ public AnalyzerWrapperAnonymousClass()
{
fieldAnalyzers.Put("field", new MockAnalyzer(Random, MockTokenizer.WHITESPACE, true, MockTokenFilter.ENGLISH_STOPSET));
fieldAnalyzers.Put("field_exact", new MockAnalyzer(Random));
diff --git a/src/Lucene.Net.Tests.Highlighter/VectorHighlight/FieldQueryTest.cs b/src/Lucene.Net.Tests.Highlighter/VectorHighlight/FieldQueryTest.cs
index 24626a4..e1f3ea1 100644
--- a/src/Lucene.Net.Tests.Highlighter/VectorHighlight/FieldQueryTest.cs
+++ b/src/Lucene.Net.Tests.Highlighter/VectorHighlight/FieldQueryTest.cs
@@ -990,7 +990,7 @@ namespace Lucene.Net.Search.VectorHighlight
phraseCandidate.Add(new TermInfo("defg", 0, 12, 0, 1));
assertNotNull(fq.SearchPhrase(F, phraseCandidate));
}
- internal class TestStopRewriteQueryAnonymousHelper : Query
+ internal class TestStopRewriteQueryAnonymousClass : Query
{
public override string ToString(string field)
{
@@ -1001,13 +1001,13 @@ namespace Lucene.Net.Search.VectorHighlight
[Test]
public void TestStopRewrite()
{
- Query q = new TestStopRewriteQueryAnonymousHelper();
+ Query q = new TestStopRewriteQueryAnonymousClass();
make1d1fIndex("a");
assertNotNull(reader);
new FieldQuery(q, reader, true, true);
}
- internal class TestFlattenFilteredQueryFilterAnonymousHelper : Filter
+ internal class TestFlattenFilteredQueryFilterAnonymousClass : Filter
{
public override DocIdSet GetDocIdSet(AtomicReaderContext context, IBits acceptDocs)
{
@@ -1019,7 +1019,7 @@ namespace Lucene.Net.Search.VectorHighlight
public void TestFlattenFilteredQuery()
{
initBoost();
- Query query = new FilteredQuery(pqF("A"), new TestFlattenFilteredQueryFilterAnonymousHelper());
+ Query query = new FilteredQuery(pqF("A"), new TestFlattenFilteredQueryFilterAnonymousClass());
query.Boost = (boost);
FieldQuery fq = new FieldQuery(query, true, true);
ISet<Query> flatQueries = new JCG.HashSet<Query>();
diff --git a/src/Lucene.Net.Tests.Highlighter/VectorHighlight/IndexTimeSynonymTest.cs b/src/Lucene.Net.Tests.Highlighter/VectorHighlight/IndexTimeSynonymTest.cs
index 7f36ba1..155c53a 100644
--- a/src/Lucene.Net.Tests.Highlighter/VectorHighlight/IndexTimeSynonymTest.cs
+++ b/src/Lucene.Net.Tests.Highlighter/VectorHighlight/IndexTimeSynonymTest.cs
@@ -323,11 +323,11 @@ namespace Lucene.Net.Search.VectorHighlight
return token;
}
- internal sealed class TokenizerAnonymousHelper : Tokenizer
+ internal sealed class TokenizerAnonymousClass : Tokenizer
{
private readonly Token[] tokens;
- public TokenizerAnonymousHelper(AttributeFactory factory, TextReader reader, Token[] tokens)
+ public TokenizerAnonymousClass(AttributeFactory factory, TextReader reader, Token[] tokens)
: base(factory, reader)
{
reusableToken = AddAttribute<ICharTermAttribute>();
@@ -362,7 +362,7 @@ namespace Lucene.Net.Search.VectorHighlight
protected internal override TokenStreamComponents CreateComponents(String fieldName, TextReader reader)
{
- Tokenizer ts = new TokenizerAnonymousHelper(Token.TOKEN_ATTRIBUTE_FACTORY, reader, tokens);
+ Tokenizer ts = new TokenizerAnonymousClass(Token.TOKEN_ATTRIBUTE_FACTORY, reader, tokens);
return new TokenStreamComponents(ts);
}
}
diff --git a/src/Lucene.Net.Tests.Join/TestJoinUtil.cs b/src/Lucene.Net.Tests.Join/TestJoinUtil.cs
index 1d62485..9d0b606 100644
--- a/src/Lucene.Net.Tests.Join/TestJoinUtil.cs
+++ b/src/Lucene.Net.Tests.Join/TestJoinUtil.cs
@@ -251,13 +251,13 @@ namespace Lucene.Net.Tests.Join
bq.Add(joinQuery, Occur.SHOULD);
bq.Add(new TermQuery(new Term("id", "3")), Occur.SHOULD);
- indexSearcher.Search(bq, new CollectorAnonymousInnerClassHelper());
+ indexSearcher.Search(bq, new CollectorAnonymousClass());
indexSearcher.IndexReader.Dispose();
dir.Dispose();
}
- private class CollectorAnonymousInnerClassHelper : ICollector
+ private class CollectorAnonymousClass : ICollector
{
internal bool sawFive;
@@ -465,7 +465,7 @@ namespace Lucene.Net.Tests.Join
FixedBitSet actualResult = new FixedBitSet(indexSearcher.IndexReader.MaxDoc);
TopScoreDocCollector topScoreDocCollector = TopScoreDocCollector.Create(10, false);
indexSearcher.Search(joinQuery,
- new CollectorAnonymousInnerClassHelper2(scoreDocsInOrder, actualResult,
+ new CollectorAnonymousClass2(scoreDocsInOrder, actualResult,
topScoreDocCollector));
// Asserting bit set...
if (Verbose)
@@ -518,13 +518,13 @@ namespace Lucene.Net.Tests.Join
}
}
- private class CollectorAnonymousInnerClassHelper2 : ICollector
+ private class CollectorAnonymousClass2 : ICollector
{
private bool scoreDocsInOrder;
private FixedBitSet actualResult;
private TopScoreDocCollector topScoreDocCollector;
- public CollectorAnonymousInnerClassHelper2(bool scoreDocsInOrder,
+ public CollectorAnonymousClass2(bool scoreDocsInOrder,
FixedBitSet actualResult,
TopScoreDocCollector topScoreDocCollector)
{
@@ -679,12 +679,12 @@ namespace Lucene.Net.Tests.Join
if (multipleValuesPerDocument)
{
fromSearcher.Search(new TermQuery(new Term("value", uniqueRandomValue)),
- new CollectorAnonymousInnerClassHelper3(fromField, joinValueToJoinScores));
+ new CollectorAnonymousClass3(fromField, joinValueToJoinScores));
}
else
{
fromSearcher.Search(new TermQuery(new Term("value", uniqueRandomValue)),
- new CollectorAnonymousInnerClassHelper4(fromField, joinValueToJoinScores));
+ new CollectorAnonymousClass4(fromField, joinValueToJoinScores));
}
IDictionary<int, JoinScore> docToJoinScore = new Dictionary<int, JoinScore>();
@@ -725,14 +725,14 @@ namespace Lucene.Net.Tests.Join
else
{
toSearcher.Search(new MatchAllDocsQuery(),
- new CollectorAnonymousInnerClassHelper5(toField, joinValueToJoinScores,
+ new CollectorAnonymousClass5(toField, joinValueToJoinScores,
docToJoinScore));
}
}
else
{
toSearcher.Search(new MatchAllDocsQuery(),
- new CollectorAnonymousInnerClassHelper6(toField, joinValueToJoinScores,
+ new CollectorAnonymousClass6(toField, joinValueToJoinScores,
docToJoinScore));
}
queryVals[uniqueRandomValue] = docToJoinScore;
@@ -744,12 +744,12 @@ namespace Lucene.Net.Tests.Join
return context;
}
- private class CollectorAnonymousInnerClassHelper3 : ICollector
+ private class CollectorAnonymousClass3 : ICollector
{
private readonly string fromField;
private readonly IDictionary<BytesRef, JoinScore> joinValueToJoinScores;
- public CollectorAnonymousInnerClassHelper3(string fromField,
+ public CollectorAnonymousClass3(string fromField,
IDictionary<BytesRef, JoinScore> joinValueToJoinScores)
{
this.fromField = fromField;
@@ -790,12 +790,12 @@ namespace Lucene.Net.Tests.Join
public virtual bool AcceptsDocsOutOfOrder => false;
}
- private class CollectorAnonymousInnerClassHelper4 : ICollector
+ private class CollectorAnonymousClass4 : ICollector
{
private readonly string fromField;
private readonly IDictionary<BytesRef, JoinScore> joinValueToJoinScores;
- public CollectorAnonymousInnerClassHelper4(string fromField,
+ public CollectorAnonymousClass4(string fromField,
IDictionary<BytesRef, JoinScore> joinValueToJoinScores)
{
this.fromField = fromField;
@@ -839,7 +839,7 @@ namespace Lucene.Net.Tests.Join
public virtual bool AcceptsDocsOutOfOrder => false;
}
- private class CollectorAnonymousInnerClassHelper5 : ICollector
+ private class CollectorAnonymousClass5 : ICollector
{
private readonly string toField;
private readonly IDictionary<BytesRef, JoinScore> joinValueToJoinScores;
@@ -849,7 +849,7 @@ namespace Lucene.Net.Tests.Join
private readonly BytesRef scratch = new BytesRef();
private int docBase;
- public CollectorAnonymousInnerClassHelper5(
+ public CollectorAnonymousClass5(
string toField, IDictionary<BytesRef, JoinScore> joinValueToJoinScores,
IDictionary<int, JoinScore> docToJoinScore)
{
@@ -892,7 +892,7 @@ namespace Lucene.Net.Tests.Join
}
}
- private class CollectorAnonymousInnerClassHelper6 : ICollector
+ private class CollectorAnonymousClass6 : ICollector
{
private readonly string toField;
private readonly IDictionary<BytesRef, JoinScore> joinValueToJoinScores;
@@ -902,7 +902,7 @@ namespace Lucene.Net.Tests.Join
private int docBase;
private readonly BytesRef spare = new BytesRef();
- public CollectorAnonymousInnerClassHelper6(
+ public CollectorAnonymousClass6(
string toField,
IDictionary<BytesRef, JoinScore> joinValueToJoinScores,
IDictionary<int, JoinScore> docToJoinScore)
diff --git a/src/Lucene.Net.Tests.Queries/TestCustomScoreQuery.cs b/src/Lucene.Net.Tests.Queries/TestCustomScoreQuery.cs
index 163f82e..16805f3 100644
--- a/src/Lucene.Net.Tests.Queries/TestCustomScoreQuery.cs
+++ b/src/Lucene.Net.Tests.Queries/TestCustomScoreQuery.cs
@@ -101,12 +101,12 @@ namespace Lucene.Net.Tests.Queries
protected override CustomScoreProvider GetCustomScoreProvider(AtomicReaderContext context)
{
- return new CustomScoreProviderAnonymousInnerClassHelper(context);
+ return new CustomScoreProviderAnonymousClass(context);
}
- private class CustomScoreProviderAnonymousInnerClassHelper : CustomScoreProvider
+ private class CustomScoreProviderAnonymousClass : CustomScoreProvider
{
- public CustomScoreProviderAnonymousInnerClassHelper(AtomicReaderContext context) : base(context)
+ public CustomScoreProviderAnonymousClass(AtomicReaderContext context) : base(context)
{
}
@@ -141,12 +141,12 @@ namespace Lucene.Net.Tests.Queries
protected override CustomScoreProvider GetCustomScoreProvider(AtomicReaderContext context)
{
- return new CustomScoreProviderAnonymousInnerClassHelper(context);
+ return new CustomScoreProviderAnonymousClass(context);
}
- private class CustomScoreProviderAnonymousInnerClassHelper : CustomScoreProvider
+ private class CustomScoreProviderAnonymousClass : CustomScoreProvider
{
- public CustomScoreProviderAnonymousInnerClassHelper(AtomicReaderContext context) : base(context)
+ public CustomScoreProviderAnonymousClass(AtomicReaderContext context) : base(context)
{
}
@@ -192,14 +192,14 @@ namespace Lucene.Net.Tests.Queries
protected override CustomScoreProvider GetCustomScoreProvider(AtomicReaderContext context)
{
FieldCache.Int32s values = FieldCache.DEFAULT.GetInt32s(context.AtomicReader, INT_FIELD, false);
- return new CustomScoreProviderAnonymousInnerClassHelper(context, values);
+ return new CustomScoreProviderAnonymousClass(context, values);
}
- private class CustomScoreProviderAnonymousInnerClassHelper : CustomScoreProvider
+ private class CustomScoreProviderAnonymousClass : CustomScoreProvider
{
private FieldCache.Int32s values;
- public CustomScoreProviderAnonymousInnerClassHelper(AtomicReaderContext context, FieldCache.Int32s values) : base(context)
+ public CustomScoreProviderAnonymousClass(AtomicReaderContext context, FieldCache.Int32s values) : base(context)
{
this.values = values;
}
diff --git a/src/Lucene.Net.Tests.Replicator/IndexAndTaxonomyReplicationClientTest.cs b/src/Lucene.Net.Tests.Replicator/IndexAndTaxonomyReplicationClientTest.cs
index 0adf72e..cd8e9f2 100644
--- a/src/Lucene.Net.Tests.Replicator/IndexAndTaxonomyReplicationClientTest.cs
+++ b/src/Lucene.Net.Tests.Replicator/IndexAndTaxonomyReplicationClientTest.cs
@@ -317,14 +317,14 @@ namespace Lucene.Net.Replicator
ISourceDirectoryFactory @in = sourceDirFactory;
AtomicInt32 failures = new AtomicInt32(AtLeast(10));
- sourceDirFactory = new SourceDirectoryFactoryAnonymousInnerClass(this, @in, failures);
+ sourceDirFactory = new SourceDirectoryFactoryAnonymousClass(this, @in, failures);
handler = new IndexAndTaxonomyReplicationHandler(handlerIndexDir, handlerTaxoDir, () =>
{
if (Random.NextDouble() < 0.2 && failures > 0)
throw new Exception("random exception from callback");
return null;
});
- client = new ReplicationClientAnonymousInnerClass(this, replicator, handler, @in, failures);
+ client = new ReplicationClientAnonymousClass(this, replicator, handler, @in, failures);
client.StartUpdateThread(10, "indexAndTaxo");
Directory baseHandlerIndexDir = handlerIndexDir.Delegate;
@@ -345,7 +345,7 @@ namespace Lucene.Net.Replicator
handlerTaxoDir.RandomIOExceptionRateOnOpen = (0.0);
}
- private class SourceDirectoryFactoryAnonymousInnerClass : ISourceDirectoryFactory
+ private class SourceDirectoryFactoryAnonymousClass : ISourceDirectoryFactory
{
private long clientMaxSize = 100, handlerIndexMaxSize = 100, handlerTaxoMaxSize = 100;
private double clientExRate = 1.0, handlerIndexExRate = 1.0, handlerTaxoExRate = 1.0;
@@ -354,7 +354,7 @@ namespace Lucene.Net.Replicator
private readonly ISourceDirectoryFactory @in;
private readonly AtomicInt32 failures;
- public SourceDirectoryFactoryAnonymousInnerClass(IndexAndTaxonomyReplicationClientTest test, ISourceDirectoryFactory @in, AtomicInt32 failures)
+ public SourceDirectoryFactoryAnonymousClass(IndexAndTaxonomyReplicationClientTest test, ISourceDirectoryFactory @in, AtomicInt32 failures)
{
this.test = test;
this.@in = @in;
@@ -417,12 +417,12 @@ namespace Lucene.Net.Replicator
- private class ReplicationClientAnonymousInnerClass : ReplicationClient
+ private class ReplicationClientAnonymousClass : ReplicationClient
{
private readonly IndexAndTaxonomyReplicationClientTest test;
private readonly AtomicInt32 failures;
- public ReplicationClientAnonymousInnerClass(IndexAndTaxonomyReplicationClientTest test, IReplicator replicator, IReplicationHandler handler, ISourceDirectoryFactory factory, AtomicInt32 failures)
+ public ReplicationClientAnonymousClass(IndexAndTaxonomyReplicationClientTest test, IReplicator replicator, IReplicationHandler handler, ISourceDirectoryFactory factory, AtomicInt32 failures)
: base(replicator, handler, factory)
{
this.test = test;
diff --git a/src/Lucene.Net.Tests.Replicator/IndexReplicationClientTest.cs b/src/Lucene.Net.Tests.Replicator/IndexReplicationClientTest.cs
index 6b4624c..3a37774 100644
--- a/src/Lucene.Net.Tests.Replicator/IndexReplicationClientTest.cs
+++ b/src/Lucene.Net.Tests.Replicator/IndexReplicationClientTest.cs
@@ -1,4 +1,4 @@
-using J2N.Threading.Atomic;
+using J2N.Threading.Atomic;
using Lucene.Net.Attributes;
using Lucene.Net.Diagnostics;
using Lucene.Net.Documents;
@@ -247,14 +247,14 @@ namespace Lucene.Net.Replicator
AtomicInt32 failures = new AtomicInt32(AtLeast(10));
// wrap sourceDirFactory to return a MockDirWrapper so we can simulate errors
- sourceDirFactory = new SourceDirectoryFactoryAnonymousInnerClass(this, @in, failures);
+ sourceDirFactory = new SourceDirectoryFactoryAnonymousClass(this, @in, failures);
handler = new IndexReplicationHandler(handlerDir, () =>
{
if (Random.NextDouble() < 0.2 && failures > 0)
throw new Exception("random exception from callback");
return null;
});
- client = new ReplicationClientAnonymousInnerClass(this, replicator, handler, sourceDirFactory, failures);
+ client = new ReplicationClientAnonymousClass(this, replicator, handler, sourceDirFactory, failures);
client.StartUpdateThread(10, "index");
Directory baseHandlerDir = handlerDir.Delegate;
@@ -272,7 +272,7 @@ namespace Lucene.Net.Replicator
handlerDir.RandomIOExceptionRateOnOpen = 0.0;
}
- private class SourceDirectoryFactoryAnonymousInnerClass : ISourceDirectoryFactory
+ private class SourceDirectoryFactoryAnonymousClass : ISourceDirectoryFactory
{
private long clientMaxSize = 100, handlerMaxSize = 100;
private double clientExRate = 1.0, handlerExRate = 1.0;
@@ -281,7 +281,7 @@ namespace Lucene.Net.Replicator
private readonly ISourceDirectoryFactory @in;
private readonly AtomicInt32 failures;
- public SourceDirectoryFactoryAnonymousInnerClass(IndexReplicationClientTest test, ISourceDirectoryFactory @in, AtomicInt32 failures)
+ public SourceDirectoryFactoryAnonymousClass(IndexReplicationClientTest test, ISourceDirectoryFactory @in, AtomicInt32 failures)
{
this.test = test;
this.@in = @in;
@@ -327,12 +327,12 @@ namespace Lucene.Net.Replicator
}
}
- private class ReplicationClientAnonymousInnerClass : ReplicationClient
+ private class ReplicationClientAnonymousClass : ReplicationClient
{
private readonly IndexReplicationClientTest test;
private readonly AtomicInt32 failures;
- public ReplicationClientAnonymousInnerClass(IndexReplicationClientTest test, IReplicator replicator, IReplicationHandler handler, ISourceDirectoryFactory factory, AtomicInt32 failures)
+ public ReplicationClientAnonymousClass(IndexReplicationClientTest test, IReplicator replicator, IReplicationHandler handler, ISourceDirectoryFactory factory, AtomicInt32 failures)
: base(replicator, handler, factory)
{
this.test = test;
diff --git a/src/Lucene.Net.Tests.Spatial/QueryEqualsHashCodeTest.cs b/src/Lucene.Net.Tests.Spatial/QueryEqualsHashCodeTest.cs
index 68a67ae..3b27e83 100644
--- a/src/Lucene.Net.Tests.Spatial/QueryEqualsHashCodeTest.cs
+++ b/src/Lucene.Net.Tests.Spatial/QueryEqualsHashCodeTest.cs
@@ -52,11 +52,11 @@ namespace Lucene.Net.Spatial
}
}
- private class ObjGeneratorQueryAnonymousHelper : ObjGenerator
+ private class ObjGeneratorQueryAnonymousClass : ObjGenerator
{
private readonly SpatialStrategy strategy;
- public ObjGeneratorQueryAnonymousHelper(SpatialStrategy strategy)
+ public ObjGeneratorQueryAnonymousClass(SpatialStrategy strategy)
{
this.strategy = strategy;
}
@@ -67,11 +67,11 @@ namespace Lucene.Net.Spatial
}
}
- private class ObjGeneratorFilterAnonymousHelper : ObjGenerator
+ private class ObjGeneratorFilterAnonymousClass : ObjGenerator
{
private readonly SpatialStrategy strategy;
- public ObjGeneratorFilterAnonymousHelper(SpatialStrategy strategy)
+ public ObjGeneratorFilterAnonymousClass(SpatialStrategy strategy)
{
this.strategy = strategy;
}
@@ -82,11 +82,11 @@ namespace Lucene.Net.Spatial
}
}
- private class ObjGeneratorDistanceValueSourceAnonymousHelper : ObjGenerator
+ private class ObjGeneratorDistanceValueSourceAnonymousClass : ObjGenerator
{
private readonly SpatialStrategy strategy;
- public ObjGeneratorDistanceValueSourceAnonymousHelper(SpatialStrategy strategy)
+ public ObjGeneratorDistanceValueSourceAnonymousClass(SpatialStrategy strategy)
{
this.strategy = strategy;
}
@@ -101,9 +101,9 @@ namespace Lucene.Net.Spatial
{
SpatialArgs args1 = MakeArgs1();
SpatialArgs args2 = MakeArgs2();
- TestEqualsHashcode(args1, args2, new ObjGeneratorQueryAnonymousHelper(strategy));
- TestEqualsHashcode(args1, args2, new ObjGeneratorFilterAnonymousHelper(strategy));
- TestEqualsHashcode(args1, args2, new ObjGeneratorDistanceValueSourceAnonymousHelper(strategy));
+ TestEqualsHashcode(args1, args2, new ObjGeneratorQueryAnonymousClass(strategy));
+ TestEqualsHashcode(args1, args2, new ObjGeneratorFilterAnonymousClass(strategy));
+ TestEqualsHashcode(args1, args2, new ObjGeneratorDistanceValueSourceAnonymousClass(strategy));
}
private void TestEqualsHashcode(SpatialArgs args1, SpatialArgs args2, ObjGenerator generator)
diff --git a/src/Lucene.Net.Tests.TestFramework/Analysis/TestMockAnalyzer.cs b/src/Lucene.Net.Tests.TestFramework/Analysis/TestMockAnalyzer.cs
index fde5e30..9777d1a 100644
--- a/src/Lucene.Net.Tests.TestFramework/Analysis/TestMockAnalyzer.cs
+++ b/src/Lucene.Net.Tests.TestFramework/Analysis/TestMockAnalyzer.cs
@@ -303,10 +303,10 @@ namespace Lucene.Net.Analysis
}
}
- private class AnalyzerWrapperAnonymousHelper : AnalyzerWrapper
+ private class AnalyzerWrapperAnonymousClass : AnalyzerWrapper
{
private readonly Analyzer @delegate;
- public AnalyzerWrapperAnonymousHelper(Analyzer @delegate)
+ public AnalyzerWrapperAnonymousClass(Analyzer @delegate)
: base(@delegate.Strategy)
{
this.@delegate = @delegate;
@@ -329,7 +329,7 @@ namespace Lucene.Net.Analysis
Random random = Random;
Analyzer @delegate = new MockAnalyzer(random);
- Analyzer a = new AnalyzerWrapperAnonymousHelper(@delegate);
+ Analyzer a = new AnalyzerWrapperAnonymousClass(@delegate);
CheckOneTerm(a, "abc", "aabc");
diff --git a/src/Lucene.Net.Tests/Analysis/TestCachingTokenFilter.cs b/src/Lucene.Net.Tests/Analysis/TestCachingTokenFilter.cs
index b96902e..87a208c 100644
--- a/src/Lucene.Net.Tests/Analysis/TestCachingTokenFilter.cs
+++ b/src/Lucene.Net.Tests/Analysis/TestCachingTokenFilter.cs
@@ -48,7 +48,7 @@ namespace Lucene.Net.Analysis
#endif
Random, dir);
Document doc = new Document();
- TokenStream stream = new TokenStreamAnonymousInnerClassHelper(this);
+ TokenStream stream = new TokenStreamAnonymousClass(this);
stream = new CachingTokenFilter(stream);
@@ -87,11 +87,11 @@ namespace Lucene.Net.Analysis
dir.Dispose();
}
- private class TokenStreamAnonymousInnerClassHelper : TokenStream
+ private class TokenStreamAnonymousClass : TokenStream
{
private TestCachingTokenFilter outerInstance;
- public TokenStreamAnonymousInnerClassHelper(TestCachingTokenFilter outerInstance)
+ public TokenStreamAnonymousClass(TestCachingTokenFilter outerInstance)
{
InitMembers(outerInstance);
}
diff --git a/src/Lucene.Net.Tests/Analysis/TestMockAnalyzer.cs b/src/Lucene.Net.Tests/Analysis/TestMockAnalyzer.cs
index 77d857f..f49f63f 100644
--- a/src/Lucene.Net.Tests/Analysis/TestMockAnalyzer.cs
+++ b/src/Lucene.Net.Tests/Analysis/TestMockAnalyzer.cs
@@ -273,18 +273,18 @@ namespace Lucene.Net.Analysis
Random random = Random;
Analyzer @delegate = new MockAnalyzer(random);
- Analyzer a = new AnalyzerWrapperAnonymousInnerClassHelper(this, @delegate.Strategy, @delegate);
+ Analyzer a = new AnalyzerWrapperAnonymousClass(this, @delegate.Strategy, @delegate);
CheckOneTerm(a, "abc", "aabc");
}
- private class AnalyzerWrapperAnonymousInnerClassHelper : AnalyzerWrapper
+ private class AnalyzerWrapperAnonymousClass : AnalyzerWrapper
{
private readonly TestMockAnalyzer outerInstance;
private Analyzer @delegate;
- public AnalyzerWrapperAnonymousInnerClassHelper(TestMockAnalyzer outerInstance, ReuseStrategy getReuseStrategy, Analyzer @delegate)
+ public AnalyzerWrapperAnonymousClass(TestMockAnalyzer outerInstance, ReuseStrategy getReuseStrategy, Analyzer @delegate)
: base(getReuseStrategy)
{
this.outerInstance = outerInstance;
@@ -314,7 +314,7 @@ namespace Lucene.Net.Analysis
int positionGap = Random.Next(1000);
int offsetGap = Random.Next(1000);
Analyzer @delegate = new MockAnalyzer(Random);
- Analyzer a = new AnalyzerWrapperAnonymousInnerClassHelper2(this, @delegate.Strategy, positionGap, offsetGap, @delegate);
+ Analyzer a = new AnalyzerWrapperAnonymousClass2(this, @delegate.Strategy, positionGap, offsetGap, @delegate);
RandomIndexWriter writer = new RandomIndexWriter(
#if FEATURE_INSTANCE_TESTDATA_INITIALIZATION
@@ -352,7 +352,7 @@ namespace Lucene.Net.Analysis
writer.IndexWriter.Directory.Dispose();
}
- private class AnalyzerWrapperAnonymousInnerClassHelper2 : AnalyzerWrapper
+ private class AnalyzerWrapperAnonymousClass2 : AnalyzerWrapper
{
private readonly TestMockAnalyzer outerInstance;
@@ -360,7 +360,7 @@ namespace Lucene.Net.Analysis
private int offsetGap;
private Analyzer @delegate;
- public AnalyzerWrapperAnonymousInnerClassHelper2(TestMockAnalyzer outerInstance, ReuseStrategy getReuseStrategy, int positionGap, int offsetGap, Analyzer @delegate)
+ public AnalyzerWrapperAnonymousClass2(TestMockAnalyzer outerInstance, ReuseStrategy getReuseStrategy, int positionGap, int offsetGap, Analyzer @delegate)
: base(getReuseStrategy)
{
this.outerInstance = outerInstance;
diff --git a/src/Lucene.Net.Tests/Analysis/TokenAttributes/TestCharTermAttributeImpl.cs b/src/Lucene.Net.Tests/Analysis/TokenAttributes/TestCharTermAttributeImpl.cs
index 1612f67..de32a2e 100644
--- a/src/Lucene.Net.Tests/Analysis/TokenAttributes/TestCharTermAttributeImpl.cs
+++ b/src/Lucene.Net.Tests/Analysis/TokenAttributes/TestCharTermAttributeImpl.cs
@@ -339,17 +339,17 @@ namespace Lucene.Net.Analysis.TokenAttributes
// finally use a completely custom ICharSequence that is not catched by instanceof checks
const string longTestString = "012345678901234567890123456789";
- t.Append(new CharSequenceAnonymousInnerClassHelper(this, longTestString));
+ t.Append(new CharSequenceAnonymousClass(this, longTestString));
Assert.AreEqual("4567890123456" + longTestString, t.ToString());
}
- private class CharSequenceAnonymousInnerClassHelper : ICharSequence
+ private class CharSequenceAnonymousClass : ICharSequence
{
private readonly TestCharTermAttributeImpl outerInstance;
private string longTestString;
- public CharSequenceAnonymousInnerClassHelper(TestCharTermAttributeImpl outerInstance, string longTestString)
+ public CharSequenceAnonymousClass(TestCharTermAttributeImpl outerInstance, string longTestString)
{
this.outerInstance = outerInstance;
this.longTestString = longTestString;
diff --git a/src/Lucene.Net.Tests/Codecs/Compressing/TestCompressingStoredFieldsFormat.cs b/src/Lucene.Net.Tests/Codecs/Compressing/TestCompressingStoredFieldsFormat.cs
index b96ecc2..fe210da 100644
--- a/src/Lucene.Net.Tests/Codecs/Compressing/TestCompressingStoredFieldsFormat.cs
+++ b/src/Lucene.Net.Tests/Codecs/Compressing/TestCompressingStoredFieldsFormat.cs
@@ -64,7 +64,7 @@ namespace Lucene.Net.Codecs.Compressing
Document invalidDoc = new Document();
FieldType fieldType = new FieldType();
fieldType.IsStored = true;
- invalidDoc.Add(new FieldAnonymousInnerClassHelper(this, fieldType));
+ invalidDoc.Add(new FieldAnonymousClass(this, fieldType));
try
{
@@ -90,11 +90,11 @@ namespace Lucene.Net.Codecs.Compressing
}
}
- private class FieldAnonymousInnerClassHelper : Field
+ private class FieldAnonymousClass : Field
{
private readonly TestCompressingStoredFieldsFormat outerInstance;
- public FieldAnonymousInnerClassHelper(TestCompressingStoredFieldsFormat outerInstance, FieldType fieldType)
+ public FieldAnonymousClass(TestCompressingStoredFieldsFormat outerInstance, FieldType fieldType)
: base("invalid", fieldType)
{
this.outerInstance = outerInstance;
diff --git a/src/Lucene.Net.Tests/Codecs/PerField/TestPerFieldDocValuesFormat.cs b/src/Lucene.Net.Tests/Codecs/PerField/TestPerFieldDocValuesFormat.cs
index 3379c03..cf3abc6 100644
--- a/src/Lucene.Net.Tests/Codecs/PerField/TestPerFieldDocValuesFormat.cs
+++ b/src/Lucene.Net.Tests/Codecs/PerField/TestPerFieldDocValuesFormat.cs
@@ -88,7 +88,7 @@ namespace Lucene.Net.Codecs.PerField
IndexWriterConfig iwc = NewIndexWriterConfig(TEST_VERSION_CURRENT, analyzer);
DocValuesFormat fast = DocValuesFormat.ForName("Lucene45");
DocValuesFormat slow = DocValuesFormat.ForName("SimpleText");
- iwc.SetCodec(new Lucene46CodecAnonymousInnerClassHelper(this, fast, slow));
+ iwc.SetCodec(new Lucene46CodecAnonymousClass(this, fast, slow));
IndexWriter iwriter = new IndexWriter(directory, iwc);
Document doc = new Document();
string longTerm = "longtermlongtermlongtermlongtermlongtermlongtermlongtermlongtermlongtermlongtermlongtermlongtermlongtermlongtermlongtermlongtermlongtermlongterm";
@@ -125,14 +125,14 @@ namespace Lucene.Net.Codecs.PerField
directory.Dispose();
}
- private class Lucene46CodecAnonymousInnerClassHelper : Lucene46Codec
+ private class Lucene46CodecAnonymousClass : Lucene46Codec
{
private readonly TestPerFieldDocValuesFormat outerInstance;
private readonly DocValuesFormat fast;
private readonly DocValuesFormat slow;
- public Lucene46CodecAnonymousInnerClassHelper(TestPerFieldDocValuesFormat outerInstance, DocValuesFormat fast, DocValuesFormat slow)
+ public Lucene46CodecAnonymousClass(TestPerFieldDocValuesFormat outerInstance, DocValuesFormat fast, DocValuesFormat slow)
{
this.outerInstance = outerInstance;
this.fast = fast;
diff --git a/src/Lucene.Net.Tests/Codecs/PerField/TestPerFieldPostingsFormat2.cs b/src/Lucene.Net.Tests/Codecs/PerField/TestPerFieldPostingsFormat2.cs
index 5e6c3a3..c1fde4f 100644
--- a/src/Lucene.Net.Tests/Codecs/PerField/TestPerFieldPostingsFormat2.cs
+++ b/src/Lucene.Net.Tests/Codecs/PerField/TestPerFieldPostingsFormat2.cs
@@ -283,15 +283,15 @@ namespace Lucene.Net.Codecs.PerField
[Test]
public virtual void TestSameCodecDifferentInstance()
{
- Codec codec = new Lucene46CodecAnonymousInnerClassHelper(this);
+ Codec codec = new Lucene46CodecAnonymousClass(this);
DoTestMixedPostings(codec);
}
- private class Lucene46CodecAnonymousInnerClassHelper : Lucene46Codec
+ private class Lucene46CodecAnonymousClass : Lucene46Codec
{
private readonly TestPerFieldPostingsFormat2 outerInstance;
- public Lucene46CodecAnonymousInnerClassHelper(TestPerFieldPostingsFormat2 outerInstance)
+ public Lucene46CodecAnonymousClass(TestPerFieldPostingsFormat2 outerInstance)
{
this.outerInstance = outerInstance;
}
@@ -316,15 +316,15 @@ namespace Lucene.Net.Codecs.PerField
[Test]
public virtual void TestSameCodecDifferentParams()
{
- Codec codec = new Lucene46CodecAnonymousInnerClassHelper2(this);
+ Codec codec = new Lucene46CodecAnonymousClass2(this);
DoTestMixedPostings(codec);
}
- private class Lucene46CodecAnonymousInnerClassHelper2 : Lucene46Codec
+ private class Lucene46CodecAnonymousClass2 : Lucene46Codec
{
private readonly TestPerFieldPostingsFormat2 outerInstance;
- public Lucene46CodecAnonymousInnerClassHelper2(TestPerFieldPostingsFormat2 outerInstance)
+ public Lucene46CodecAnonymousClass2(TestPerFieldPostingsFormat2 outerInstance)
{
this.outerInstance = outerInstance;
}
diff --git a/src/Lucene.Net.Tests/Index/TestAddIndexes.cs b/src/Lucene.Net.Tests/Index/TestAddIndexes.cs
index 4411103..395eb13 100644
--- a/src/Lucene.Net.Tests/Index/TestAddIndexes.cs
+++ b/src/Lucene.Net.Tests/Index/TestAddIndexes.cs
@@ -671,7 +671,7 @@ namespace Lucene.Net.Index
{
for (int i = 0; i < NUM_THREADS; i++)
{
- threads[i] = new ThreadAnonymousInnerClassHelper(this, numIter);
+ threads[i] = new ThreadAnonymousClass(this, numIter);
}
for (int i = 0; i < NUM_THREADS; i++)
@@ -680,12 +680,12 @@ namespace Lucene.Net.Index
}
}
- private class ThreadAnonymousInnerClassHelper : ThreadJob
+ private class ThreadAnonymousClass : ThreadJob
{
private readonly RunAddIndexesThreads outerInstance;
private readonly int numIter;
- public ThreadAnonymousInnerClassHelper(RunAddIndexesThreads outerInstance, int numIter)
+ public ThreadAnonymousClass(RunAddIndexesThreads outerInstance, int numIter)
{
this.outerInstance = outerInstance;
this.numIter = numIter;
diff --git a/src/Lucene.Net.Tests/Index/TestBagOfPositions.cs b/src/Lucene.Net.Tests/Index/TestBagOfPositions.cs
index fbe7193..8e36ab4 100644
--- a/src/Lucene.Net.Tests/Index/TestBagOfPositions.cs
+++ b/src/Lucene.Net.Tests/Index/TestBagOfPositions.cs
@@ -125,7 +125,7 @@ namespace Lucene.Net.Index
Document document = new Document();
Field field = new Field("field", "", fieldType);
document.Add(field);
- threads[threadID] = new ThreadAnonymousInnerClassHelper(this, numTerms, maxTermsPerDoc, postings, iw, startingGun, threadRandom, document, field);
+ threads[threadID] = new ThreadAnonymousClass(this, numTerms, maxTermsPerDoc, postings, iw, startingGun, threadRandom, document, field);
threads[threadID].Start();
}
startingGun.Signal();
@@ -155,7 +155,7 @@ namespace Lucene.Net.Index
dir.Dispose();
}
- private class ThreadAnonymousInnerClassHelper : ThreadJob
+ private class ThreadAnonymousClass : ThreadJob
{
private readonly TestBagOfPositions outerInstance;
@@ -168,7 +168,7 @@ namespace Lucene.Net.Index
private readonly Document document;
private readonly Field field;
- public ThreadAnonymousInnerClassHelper(TestBagOfPositions outerInstance, int numTerms, int maxTermsPerDoc, ConcurrentQueue<string> postings, RandomIndexWriter iw, CountdownEvent startingGun, Random threadRandom, Document document, Field field)
+ public ThreadAnonymousClass(TestBagOfPositions outerInstance, int numTerms, int maxTermsPerDoc, ConcurrentQueue<string> postings, RandomIndexWriter iw, CountdownEvent startingGun, Random threadRandom, Document document, Field field)
{
this.outerInstance = outerInstance;
this.numTerms = numTerms;
diff --git a/src/Lucene.Net.Tests/Index/TestBagOfPostings.cs b/src/Lucene.Net.Tests/Index/TestBagOfPostings.cs
index e26a81b..656764f 100644
--- a/src/Lucene.Net.Tests/Index/TestBagOfPostings.cs
+++ b/src/Lucene.Net.Tests/Index/TestBagOfPostings.cs
@@ -101,7 +101,7 @@ namespace Lucene.Net.Index
for (int threadID = 0; threadID < threadCount; threadID++)
{
- threads[threadID] = new ThreadAnonymousInnerClassHelper(this, maxTermsPerDoc, postings, iw, startingGun);
+ threads[threadID] = new ThreadAnonymousClass(this, maxTermsPerDoc, postings, iw, startingGun);
threads[threadID].Start();
}
startingGun.Signal();
@@ -137,7 +137,7 @@ namespace Lucene.Net.Index
dir.Dispose();
}
- private class ThreadAnonymousInnerClassHelper : ThreadJob
+ private class ThreadAnonymousClass : ThreadJob
{
private readonly TestBagOfPostings outerInstance;
@@ -146,7 +146,7 @@ namespace Lucene.Net.Index
private readonly RandomIndexWriter iw;
private readonly CountdownEvent startingGun;
- public ThreadAnonymousInnerClassHelper(TestBagOfPostings outerInstance, int maxTermsPerDoc, ConcurrentQueue<string> postings, RandomIndexWriter iw, CountdownEvent startingGun)
+ public ThreadAnonymousClass(TestBagOfPostings outerInstance, int maxTermsPerDoc, ConcurrentQueue<string> postings, RandomIndexWriter iw, CountdownEvent startingGun)
{
this.outerInstance = outerInstance;
this.maxTermsPerDoc = maxTermsPerDoc;
diff --git a/src/Lucene.Net.Tests/Index/TestBinaryDocValuesUpdates.cs b/src/Lucene.Net.Tests/Index/TestBinaryDocValuesUpdates.cs
index 29f2f4a..6148f47 100644
--- a/src/Lucene.Net.Tests/Index/TestBinaryDocValuesUpdates.cs
+++ b/src/Lucene.Net.Tests/Index/TestBinaryDocValuesUpdates.cs
@@ -674,7 +674,7 @@ namespace Lucene.Net.Index
{
Directory dir = NewDirectory();
IndexWriterConfig conf = NewIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(Random));
- conf.SetCodec(new Lucene46CodecAnonymousInnerClassHelper(this));
+ conf.SetCodec(new Lucene46CodecAnonymousClass(this));
IndexWriter writer = new IndexWriter(dir, conf);
Document doc = new Document();
@@ -705,11 +705,11 @@ namespace Lucene.Net.Index
dir.Dispose();
}
- private class Lucene46CodecAnonymousInnerClassHelper : Lucene46Codec
+ private class Lucene46CodecAnonymousClass : Lucene46Codec
{
private readonly TestBinaryDocValuesUpdates outerInstance;
- public Lucene46CodecAnonymousInnerClassHelper(TestBinaryDocValuesUpdates outerInstance)
+ public Lucene46CodecAnonymousClass(TestBinaryDocValuesUpdates outerInstance)
{
this.outerInstance = outerInstance;
}
@@ -1246,7 +1246,7 @@ namespace Lucene.Net.Index
{
string f = "f" + i;
string cf = "cf" + i;
- threads[i] = new ThreadAnonymousInnerClassHelper(this, "UpdateThread-" + i, writer, numDocs, done, numUpdates, f, cf);
+ threads[i] = new ThreadAnonymousClass(this, "UpdateThread-" + i, writer, numDocs, done, numUpdates, f, cf);
}
foreach (ThreadJob t in threads)
@@ -1286,7 +1286,7 @@ namespace Lucene.Net.Index
dir.Dispose();
}
- private class ThreadAnonymousInnerClassHelper : ThreadJob
+ private class ThreadAnonymousClass : ThreadJob
{
private readonly TestBinaryDocValuesUpdates outerInstance;
@@ -1297,7 +1297,7 @@ namespace Lucene.Net.Index
private readonly string f;
private readonly string cf;
- public ThreadAnonymousInnerClassHelper(TestBinaryDocValuesUpdates outerInstance, string str, IndexWriter writer, int numDocs, CountdownEvent done, AtomicInt32 numUpdates, string f, string cf)
+ public ThreadAnonymousClass(TestBinaryDocValuesUpdates outerInstance, string str, IndexWriter writer, int numDocs, CountdownEvent done, AtomicInt32 numUpdates, string f, string cf)
: base(str)
{
this.outerInstance = outerInstance;
@@ -1461,7 +1461,7 @@ namespace Lucene.Net.Index
Directory dir = NewDirectory();
IndexWriterConfig conf = NewIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(Random));
conf.SetMergePolicy(NoMergePolicy.COMPOUND_FILES); // disable merges to simplify test assertions.
- conf.SetCodec(new Lucene46CodecAnonymousInnerClassHelper2(this));
+ conf.SetCodec(new Lucene46CodecAnonymousClass2(this));
IndexWriter writer = new IndexWriter(dir, (IndexWriterConfig)conf.Clone());
Document doc = new Document();
doc.Add(new StringField("id", "d0", Store.NO));
@@ -1471,7 +1471,7 @@ namespace Lucene.Net.Index
writer.Dispose();
// change format
- conf.SetCodec(new Lucene46CodecAnonymousInnerClassHelper3(this));
+ conf.SetCodec(new Lucene46CodecAnonymousClass3(this));
writer = new IndexWriter(dir, (IndexWriterConfig)conf.Clone());
doc = new Document();
doc.Add(new StringField("id", "d1", Store.NO));
@@ -1494,11 +1494,11 @@ namespace Lucene.Net.Index
dir.Dispose();
}
- private class Lucene46CodecAnonymousInnerClassHelper2 : Lucene46Codec
+ private class Lucene46CodecAnonymousClass2 : Lucene46Codec
{
private readonly TestBinaryDocValuesUpdates outerInstance;
- public Lucene46CodecAnonymousInnerClassHelper2(TestBinaryDocValuesUpdates outerInstance)
+ public Lucene46CodecAnonymousClass2(TestBinaryDocValuesUpdates outerInstance)
{
this.outerInstance = outerInstance;
}
@@ -1509,11 +1509,11 @@ namespace Lucene.Net.Index
}
}
- private class Lucene46CodecAnonymousInnerClassHelper3 : Lucene46Codec
+ private class Lucene46CodecAnonymousClass3 : Lucene46Codec
{
private readonly TestBinaryDocValuesUpdates outerInstance;
- public Lucene46CodecAnonymousInnerClassHelper3(TestBinaryDocValuesUpdates outerInstance)
+ public Lucene46CodecAnonymousClass3(TestBinaryDocValuesUpdates outerInstance)
{
this.outerInstance = outerInstance;
}
diff --git a/src/Lucene.Net.Tests/Index/TestCodecs.cs b/src/Lucene.Net.Tests/Index/TestCodecs.cs
index 8c9e94b..f38f82e 100644
--- a/src/Lucene.Net.Tests/Index/TestCodecs.cs
+++ b/src/Lucene.Net.Tests/Index/TestCodecs.cs
@@ -112,7 +112,7 @@ namespace Lucene.Net.Index
this.omitTF = omitTF;
this.storePayloads = storePayloads;
// TODO: change this test to use all three
- fieldInfo = fieldInfos.AddOrUpdate(name, new IndexableFieldTypeAnonymousInnerClassHelper(this, omitTF));
+ fieldInfo = fieldInfos.AddOrUpdate(name, new IndexableFieldTypeAnonymousClass(this, omitTF));
if (storePayloads)
{
fieldInfo.SetStorePayloads();
@@ -126,12 +126,12 @@ namespace Lucene.Net.Index
Array.Sort(terms);
}
- private class IndexableFieldTypeAnonymousInnerClassHelper : IIndexableFieldType
+ private class IndexableFieldTypeAnonymousClass : IIndexableFieldType
{
private readonly FieldData outerInstance;
private readonly bool omitTF;
- public IndexableFieldTypeAnonymousInnerClassHelper(FieldData outerInstance, bool omitTF)
+ public IndexableFieldTypeAnonymousClass(FieldData outerInstance, bool omitTF)
{
this.outerInstance = outerInstance;
this.omitTF = omitTF;
diff --git a/src/Lucene.Net.Tests/Index/TestConcurrentMergeScheduler.cs b/src/Lucene.Net.Tests/Index/TestConcurrentMergeScheduler.cs
index a43aed1..bb9ac45 100644
--- a/src/Lucene.Net.Tests/Index/TestConcurrentMergeScheduler.cs
+++ b/src/Lucene.Net.Tests/Index/TestConcurrentMergeScheduler.cs
@@ -296,7 +296,7 @@ namespace Lucene.Net.Index
Console.WriteLine("TEST: maxMergeCount=" + maxMergeCount + " maxMergeThreads=" + maxMergeThreads);
}
- ConcurrentMergeScheduler cms = new ConcurrentMergeSchedulerAnonymousInnerClassHelper(this, maxMergeCount, enoughMergesWaiting, runningMergeCount, failed);
+ ConcurrentMergeScheduler cms = new ConcurrentMergeSchedulerAnonymousClass(this, maxMergeCount, enoughMergesWaiting, runningMergeCount, failed);
cms.SetMaxMergesAndThreads(maxMergeCount, maxMergeThreads);
iwc.SetMergeScheduler(cms);
iwc.SetMaxBufferedDocs(2);
@@ -320,7 +320,7 @@ namespace Lucene.Net.Index
dir.Dispose();
}
- private class ConcurrentMergeSchedulerAnonymousInnerClassHelper : ConcurrentMergeScheduler
+ private class ConcurrentMergeSchedulerAnonymousClass : ConcurrentMergeScheduler
{
private readonly TestConcurrentMergeScheduler outerInstance;
@@ -329,7 +329,7 @@ namespace Lucene.Net.Index
private readonly AtomicInt32 runningMergeCount;
private readonly AtomicBoolean failed;
- public ConcurrentMergeSchedulerAnonymousInnerClassHelper(TestConcurrentMergeScheduler outerInstance, int maxMergeCount, CountdownEvent enoughMergesWaiting, AtomicInt32 runningMergeCount, AtomicBoolean failed)
+ public ConcurrentMergeSchedulerAnonymousClass(TestConcurrentMergeScheduler outerInstance, int maxMergeCount, CountdownEvent enoughMergesWaiting, AtomicInt32 runningMergeCount, AtomicBoolean failed)
{
this.outerInstance = outerInstance;
this.maxMergeCount = maxMergeCount;
diff --git a/src/Lucene.Net.Tests/Index/TestDirectoryReader.cs b/src/Lucene.Net.Tests/Index/TestDirectoryReader.cs
index b88b65b..dbdf310 100644
--- a/src/Lucene.Net.Tests/Index/TestDirectoryReader.cs
+++ b/src/Lucene.Net.Tests/Index/TestDirectoryReader.cs
@@ -1110,7 +1110,7 @@ namespace Lucene.Net.Index
writer.Commit();
DirectoryReader reader = writer.GetReader();
int[] closeCount = new int[1];
- IndexReader.IReaderClosedListener listener = new ReaderClosedListenerAnonymousInnerClassHelper(this, reader, closeCount);
+ IndexReader.IReaderClosedListener listener = new ReaderClosedListenerAnonymousClass(this, reader, closeCount);
reader.AddReaderClosedListener(listener);
@@ -1129,14 +1129,14 @@ namespace Lucene.Net.Index
dir.Dispose();
}
- private class ReaderClosedListenerAnonymousInnerClassHelper : IndexReader.IReaderClosedListener
+ private class ReaderClosedListenerAnonymousClass : IndexReader.IReaderClosedListener
{
private readonly TestDirectoryReader outerInstance;
private readonly DirectoryReader reader;
private readonly int[] closeCount;
- public ReaderClosedListenerAnonymousInnerClassHelper(TestDirectoryReader outerInstance, DirectoryReader reader, int[] closeCount)
+ public ReaderClosedListenerAnonymousClass(TestDirectoryReader outerInstance, DirectoryReader reader, int[] closeCount)
{
this.outerInstance = outerInstance;
this.reader = reader;
diff --git a/src/Lucene.Net.Tests/Index/TestDirectoryReaderReopen.cs b/src/Lucene.Net.Tests/Index/TestDirectoryReaderReopen.cs
index 578649f..a921184 100644
--- a/src/Lucene.Net.Tests/Index/TestDirectoryReaderReopen.cs
+++ b/src/Lucene.Net.Tests/Index/TestDirectoryReaderReopen.cs
@@ -51,23 +51,23 @@ namespace Lucene.Net.Index
Directory dir1 = NewDirectory();
CreateIndex(Random, dir1, false);
- PerformDefaultTests(new TestReopenAnonymousInnerClassHelper(this, dir1));
+ PerformDefaultTests(new TestReopenAnonymousClass(this, dir1));
dir1.Dispose();
Directory dir2 = NewDirectory();
CreateIndex(Random, dir2, true);
- PerformDefaultTests(new TestReopenAnonymousInnerClassHelper2(this, dir2));
+ PerformDefaultTests(new TestReopenAnonymousClass2(this, dir2));
dir2.Dispose();
}
- private class TestReopenAnonymousInnerClassHelper : TestReopen
+ private class TestReopenAnonymousClass : TestReopen
{
private readonly TestDirectoryReaderReopen outerInstance;
private Directory dir1;
- public TestReopenAnonymousInnerClassHelper(TestDirectoryReaderReopen outerInstance, Directory dir1)
+ public TestReopenAnonymousClass(TestDirectoryReaderReopen outerInstance, Directory dir1)
{
this.outerInstance = outerInstance;
this.dir1 = dir1;
@@ -84,13 +84,13 @@ namespace Lucene.Net.Index
}
}
- private class TestReopenAnonymousInnerClassHelper2 : TestReopen
+ private class TestReopenAnonymousClass2 : TestReopen
{
private readonly TestDirectoryReaderReopen outerInstance;
private readonly Directory dir2;
- public TestReopenAnonymousInnerClassHelper2(TestDirectoryReaderReopen outerInstance, Directory dir2)
+ public TestReopenAnonymousClass2(TestDirectoryReaderReopen outerInstance, Directory dir2)
{
this.outerInstance = outerInstance;
this.dir2 = dir2;
@@ -248,7 +248,7 @@ namespace Lucene.Net.Index
writer.ForceMerge(1);
writer.Dispose();
- TestReopen test = new TestReopenAnonymousInnerClassHelper3(this, dir, n);
+ TestReopen test = new TestReopenAnonymousClass3(this, dir, n);
IList<ReaderCouple> readers = new SynchronizedList<ReaderCouple>();
DirectoryReader firstReader = DirectoryReader.Open(dir);
@@ -276,11 +276,11 @@ namespace Lucene.Net.Index
if (i < 4 || (i >= 10 && i < 14) || i > 18)
{
- task = new ReaderThreadTaskAnonymousInnerClassHelper(this, test, readers, readersToClose, r, index);
+ task = new ReaderThreadTaskAnonymousClass(this, test, readers, readersToClose, r, index);
}
else
{
- task = new ReaderThreadTaskAnonymousInnerClassHelper2(this, readers);
+ task = new ReaderThreadTaskAnonymousClass2(this, readers);
}
threads[i] = new ReaderThread(task);
@@ -332,14 +332,14 @@ namespace Lucene.Net.Index
dir.Dispose();
}
- private class TestReopenAnonymousInnerClassHelper3 : TestReopen
+ private class TestReopenAnonymousClass3 : TestReopen
{
private readonly TestDirectoryReaderReopen outerInstance;
private readonly Directory dir;
private readonly int n;
- public TestReopenAnonymousInnerClassHelper3(TestDirectoryReaderReopen outerInstance, Directory dir, int n)
+ public TestReopenAnonymousClass3(TestDirectoryReaderReopen outerInstance, Directory dir, int n)
{
this.outerInstance = outerInstance;
this.dir = dir;
@@ -359,7 +359,7 @@ namespace Lucene.Net.Index
}
}
- private class ReaderThreadTaskAnonymousInnerClassHelper : ReaderThreadTask
+ private class ReaderThreadTaskAnonymousClass : ReaderThreadTask
{
private readonly TestDirectoryReaderReopen outerInstance;
@@ -369,7 +369,7 @@ namespace Lucene.Net.Index
private readonly DirectoryReader r;
private readonly int index;
- public ReaderThreadTaskAnonymousInnerClassHelper(TestDirectoryReaderReopen outerInstance, Lucene.Net.Index.TestDirectoryReaderReopen.TestReopen test, IList<ReaderCouple> readers, ISet<DirectoryReader> readersToClose, DirectoryReader r, int index)
+ public ReaderThreadTaskAnonymousClass(TestDirectoryReaderReopen outerInstance, Lucene.Net.Index.TestDirectoryReaderReopen.TestReopen test, IList<ReaderCouple> readers, ISet<DirectoryReader> readersToClose, DirectoryReader r, int index)
{
this.outerInstance = outerInstance;
this.test = test;
@@ -426,13 +426,13 @@ namespace Lucene.Net.Index
}
}
- private class ReaderThreadTaskAnonymousInnerClassHelper2 : ReaderThreadTask
+ private class ReaderThreadTaskAnonymousClass2 : ReaderThreadTask
{
private readonly TestDirectoryReaderReopen outerInstance;
private readonly IList<ReaderCouple> readers;
- public ReaderThreadTaskAnonymousInnerClassHelper2(TestDirectoryReaderReopen outerInstance, IList<ReaderCouple> readers)
+ public ReaderThreadTaskAnonymousClass2(TestDirectoryReaderReopen outerInstance, IList<ReaderCouple> readers)
{
this.outerInstance = outerInstance;
this.readers = readers;
diff --git a/src/Lucene.Net.Tests/Index/TestDocInverterPerFieldErrorInfo.cs b/src/Lucene.Net.Tests/Index/TestDocInverterPerFieldErrorInfo.cs
index 68b9738..1ff88a5 100644
--- a/src/Lucene.Net.Tests/Index/TestDocInverterPerFieldErrorInfo.cs
+++ b/src/Lucene.Net.Tests/Index/TestDocInverterPerFieldErrorInfo.cs
@@ -60,7 +60,7 @@ namespace Lucene.Net.Index
Tokenizer tokenizer = new MockTokenizer(input);
if (fieldName.Equals("distinctiveFieldName", StringComparison.Ordinal))
{
- TokenFilter tosser = new TokenFilterAnonymousInnerClassHelper(this, tokenizer);
+ TokenFilter tosser = new TokenFilterAnonymousClass(this, tokenizer);
return new TokenStreamComponents(tokenizer, tosser);
}
else
@@ -69,11 +69,11 @@ namespace Lucene.Net.Index
}
}
- private class TokenFilterAnonymousInnerClassHelper : TokenFilter
+ private class TokenFilterAnonymousClass : TokenFilter
{
private readonly ThrowingAnalyzer outerInstance;
- public TokenFilterAnonymousInnerClassHelper(ThrowingAnalyzer outerInstance, Tokenizer tokenizer)
+ public TokenFilterAnonymousClass(ThrowingAnalyzer outerInstance, Tokenizer tokenizer)
: base(tokenizer)
{
this.outerInstance = outerInstance;
diff --git a/src/Lucene.Net.Tests/Index/TestDocValuesIndexing.cs b/src/Lucene.Net.Tests/Index/TestDocValuesIndexing.cs
index cc77cf6..1a5da9c 100644
--- a/src/Lucene.Net.Tests/Index/TestDocValuesIndexing.cs
+++ b/src/Lucene.Net.Tests/Index/TestDocValuesIndexing.cs
@@ -580,7 +580,7 @@ namespace Lucene.Net.Index
Document doc = new Document();
doc.Add(field);
- threads[i] = new ThreadAnonymousInnerClassHelper(this, w, startingGun, hitExc, doc);
+ threads[i] = new ThreadAnonymousClass(this, w, startingGun, hitExc, doc);
threads[i].Start();
}
@@ -595,7 +595,7 @@ namespace Lucene.Net.Index
dir.Dispose();
}
- private class ThreadAnonymousInnerClassHelper : ThreadJob
+ private class ThreadAnonymousClass : ThreadJob
{
private readonly TestDocValuesIndexing outerInstance;
@@ -604,7 +604,7 @@ namespace Lucene.Net.Index
private readonly AtomicBoolean hitExc;
private readonly Document doc;
- public ThreadAnonymousInnerClassHelper(TestDocValuesIndexing outerInstance, IndexWriter w, CountdownEvent startingGun, AtomicBoolean hitExc, Document doc)
+ public ThreadAnonymousClass(TestDocValuesIndexing outerInstance, IndexWriter w, CountdownEvent startingGun, AtomicBoolean hitExc, Document doc)
{
this.outerInstance = outerInstance;
this.w = w;
diff --git a/src/Lucene.Net.Tests/Index/TestDocValuesWithThreads.cs b/src/Lucene.Net.Tests/Index/TestDocValuesWithThreads.cs
index 719500a..d02467a 100644
--- a/src/Lucene.Net.Tests/Index/TestDocValuesWithThreads.cs
+++ b/src/Lucene.Net.Tests/Index/TestDocValuesWithThreads.cs
@@ -82,7 +82,7 @@ namespace Lucene.Net.Index
for (int t = 0; t < numThreads; t++)
{
Random threadRandom = new Random(Random.Next());
- ThreadJob thread = new ThreadAnonymousInnerClassHelper(this, numbers, binary, sorted, numDocs, ar, startingGun, threadRandom);
+ ThreadJob thread = new ThreadAnonymousClass(this, numbers, binary, sorted, numDocs, ar, startingGun, threadRandom);
thread.Start();
threads.Add(thread);
}
@@ -98,7 +98,7 @@ namespace Lucene.Net.Index
dir.Dispose();
}
- private class ThreadAnonymousInnerClassHelper : ThreadJob
+ private class ThreadAnonymousClass : ThreadJob
{
private readonly TestDocValuesWithThreads outerInstance;
@@ -110,7 +110,7 @@ namespace Lucene.Net.Index
private readonly CountdownEvent startingGun;
private readonly Random threadRandom;
- public ThreadAnonymousInnerClassHelper(TestDocValuesWithThreads outerInstance, IList<long?> numbers, IList<BytesRef> binary, IList<BytesRef> sorted, int numDocs, AtomicReader ar, CountdownEvent startingGun, Random threadRandom)
+ public ThreadAnonymousClass(TestDocValuesWithThreads outerInstance, IList<long?> numbers, IList<BytesRef> binary, IList<BytesRef> sorted, int numDocs, AtomicReader ar, CountdownEvent startingGun, Random threadRandom)
{
this.outerInstance = outerInstance;
this.numbers = numbers;
@@ -255,7 +255,7 @@ namespace Lucene.Net.Index
ThreadJob[] threads = new ThreadJob[NUM_THREADS];
for (int thread = 0; thread < NUM_THREADS; thread++)
{
- threads[thread] = new ThreadAnonymousInnerClassHelper2(random, docValues, sr, END_TIME);
+ threads[thread] = new ThreadAnonymousClass2(random, docValues, sr, END_TIME);
threads[thread].Start();
}
@@ -268,14 +268,14 @@ namespace Lucene.Net.Index
dir.Dispose();
}
- private class ThreadAnonymousInnerClassHelper2 : ThreadJob
+ private class ThreadAnonymousClass2 : ThreadJob
{
private readonly Random random;
private readonly IList<BytesRef> docValues;
private readonly AtomicReader sr;
private readonly long endTime;
- public ThreadAnonymousInnerClassHelper2(Random random, IList<BytesRef> docValues, AtomicReader sr, long endTime)
+ public ThreadAnonymousClass2(Random random, IList<BytesRef> docValues, AtomicReader sr, long endTime)
{
this.random = random;
this.docValues = docValues;
diff --git a/src/Lucene.Net.Tests/Index/TestDocumentWriter.cs b/src/Lucene.Net.Tests/Index/TestDocumentWriter.cs
index d8c57f0..316f393 100644
--- a/src/Lucene.Net.Tests/Index/TestDocumentWriter.cs
+++ b/src/Lucene.Net.Tests/Index/TestDocumentWriter.cs
@@ -117,7 +117,7 @@ namespace Lucene.Net.Index
[Test]
public virtual void TestPositionIncrementGap()
{
- Analyzer analyzer = new AnalyzerAnonymousInnerClassHelper();
+ Analyzer analyzer = new AnalyzerAnonymousClass();
IndexWriter writer = new IndexWriter(dir, NewIndexWriterConfig(TEST_VERSION_CURRENT, analyzer));
@@ -140,7 +140,7 @@ namespace Lucene.Net.Index
reader.Dispose();
}
- private class AnalyzerAnonymousInnerClassHelper : Analyzer
+ private class AnalyzerAnonymousClass : Analyzer
{
protected internal override TokenStreamComponents CreateComponents(string fieldName, TextReader reader)
{
@@ -156,7 +156,7 @@ namespace Lucene.Net.Index
[Test]
public virtual void TestTokenReuse()
{
- Analyzer analyzer = new AnalyzerAnonymousInnerClassHelper2(this);
+ Analyzer analyzer = new AnalyzerAnonymousClass2(this);
IndexWriter writer = new IndexWriter(dir, NewIndexWriterConfig(TEST_VERSION_CURRENT, analyzer));
@@ -182,11 +182,11 @@ namespace Lucene.Net.Index
reader.Dispose();
}
- private class AnalyzerAnonymousInnerClassHelper2 : Analyzer
+ private class AnalyzerAnonymousClass2 : Analyzer
{
private readonly TestDocumentWriter outerInstance;
- public AnalyzerAnonymousInnerClassHelper2(TestDocumentWriter outerInstance)
+ public AnalyzerAnonymousClass2(TestDocumentWriter outerInstance)
{
this.outerInstance = outerInstance;
}
@@ -194,14 +194,14 @@ namespace Lucene.Net.Index
protected internal override TokenStreamComponents CreateComponents(string fieldName, TextReader reader)
{
Tokenizer tokenizer = new MockTokenizer(reader, MockTokenizer.WHITESPACE, false);
- return new TokenStreamComponents(tokenizer, new TokenFilterAnonymousInnerClassHelper(this, tokenizer));
+ return new TokenStreamComponents(tokenizer, new TokenFilterAnonymousClass(this, tokenizer));
}
- private class TokenFilterAnonymousInnerClassHelper : TokenFilter
+ private class TokenFilterAnonymousClass : TokenFilter
{
- private readonly AnalyzerAnonymousInnerClassHelper2 outerInstance;
+ private readonly AnalyzerAnonymousClass2 outerInstance;
- public TokenFilterAnonymousInnerClassHelper(AnalyzerAnonymousInnerClassHelper2 outerInstance, Tokenizer tokenizer)
+ public TokenFilterAnonymousClass(AnalyzerAnonymousClass2 outerInstance, Tokenizer tokenizer)
: base(tokenizer)
{
this.outerInstance = outerInstance;
@@ -266,7 +266,7 @@ namespace Lucene.Net.Index
IndexWriter writer = new IndexWriter(dir, NewIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(Random)));
Document doc = new Document();
- doc.Add(new TextField("preanalyzed", new TokenStreamAnonymousInnerClassHelper(this)));
+ doc.Add(new TextField("preanalyzed", new TokenStreamAnonymousClass(this)));
writer.AddDocument(doc);
writer.Commit();
@@ -292,11 +292,11 @@ namespace Lucene.Net.Index
reader.Dispose();
}
- private class TokenStreamAnonymousInnerClassHelper : TokenStream
+ private class TokenStreamAnonymousClass : TokenStream
{
private readonly TestDocumentWriter outerInstance;
- public TokenStreamAnonymousInnerClassHelper(TestDocumentWriter outerInstance)
+ public TokenStreamAnonymousClass(TestDocumentWriter outerInstance)
{
this.outerInstance = outerInstance;
tokens = new string[] { "term1", "term2", "term3", "term2" };
diff --git a/src/Lucene.Net.Tests/Index/TestDocumentsWriterDeleteQueue.cs b/src/Lucene.Net.Tests/Index/TestDocumentsWriterDeleteQueue.cs
index cc68b06..fc77f34 100644
--- a/src/Lucene.Net.Tests/Index/TestDocumentsWriterDeleteQueue.cs
+++ b/src/Lucene.Net.Tests/Index/TestDocumentsWriterDeleteQueue.cs
@@ -217,7 +217,7 @@ namespace Lucene.Net.Index
BindingFlags.NonPublic | BindingFlags.GetField | BindingFlags.Instance);
ReentrantLock @lock = (ReentrantLock)field.GetValue(queue);
@lock.Lock();
- var t = new ThreadAnonymousInnerClassHelper(this, queue);
+ var t = new ThreadAnonymousClass(this, queue);
t.Start();
t.Join();
@lock.Unlock();
@@ -230,13 +230,13 @@ namespace Lucene.Net.Index
Assert.IsFalse(queue.AnyChanges(), "all changes applied");
}
- private class ThreadAnonymousInnerClassHelper : ThreadJob
+ private class ThreadAnonymousClass : ThreadJob
{
private readonly TestDocumentsWriterDeleteQueue outerInstance;
private DocumentsWriterDeleteQueue queue;
- public ThreadAnonymousInnerClassHelper(TestDocumentsWriterDeleteQueue outerInstance, DocumentsWriterDeleteQueue queue)
+ public ThreadAnonymousClass(TestDocumentsWriterDeleteQueue outerInstance, DocumentsWriterDeleteQueue queue)
{
this.outerInstance = outerInstance;
this.queue = queue;
diff --git a/src/Lucene.Net.Tests/Index/TestDocumentsWriterStallControl.cs b/src/Lucene.Net.Tests/Index/TestDocumentsWriterStallControl.cs
index 6faf12d..8cb184b 100644
--- a/src/Lucene.Net.Tests/Index/TestDocumentsWriterStallControl.cs
+++ b/src/Lucene.Net.Tests/Index/TestDocumentsWriterStallControl.cs
@@ -69,7 +69,7 @@ namespace Lucene.Net.Index
for (int i = 0; i < stallThreads.Length; i++)
{
int stallProbability = 1 + Random.Next(10);
- stallThreads[i] = new ThreadAnonymousInnerClassHelper(ctrl, stallProbability);
+ stallThreads[i] = new ThreadAnonymousClass(ctrl, stallProbability);
}
Start(stallThreads);
long time = Environment.TickCount;
@@ -92,12 +92,12 @@ namespace Lucene.Net.Index
Join(stallThreads);
}
- private class ThreadAnonymousInnerClassHelper : ThreadJob
+ private class ThreadAnonymousClass : ThreadJob
{
private readonly DocumentsWriterStallControl ctrl;
private readonly int stallProbability;
- public ThreadAnonymousInnerClassHelper(DocumentsWriterStallControl ctrl, int stallProbability)
+ public ThreadAnonymousClass(DocumentsWriterStallControl ctrl, int stallProbability)
{
this.ctrl = ctrl;
this.stallProbability = stallProbability;
@@ -401,16 +401,16 @@ namespace Lucene.Net.Index
ThreadJob[] array = new ThreadJob[num];
for (int i = 0; i < array.Length; i++)
{
- array[i] = new ThreadAnonymousInnerClassHelper2(ctrl);
+ array[i] = new ThreadAnonymousClass2(ctrl);
}
return array;
}
- private class ThreadAnonymousInnerClassHelper2 : ThreadJob
+ private class ThreadAnonymousClass2 : ThreadJob
{
private readonly DocumentsWriterStallControl ctrl;
- public ThreadAnonymousInnerClassHelper2(DocumentsWriterStallControl ctrl)
+ public ThreadAnonymousClass2(DocumentsWriterStallControl ctrl)
{
this.ctrl = ctrl;
}
diff --git a/src/Lucene.Net.Tests/Index/TestForceMergeForever.cs b/src/Lucene.Net.Tests/Index/TestForceMergeForever.cs
index 84cb2e2..2783af2 100644
--- a/src/Lucene.Net.Tests/Index/TestForceMergeForever.cs
+++ b/src/Lucene.Net.Tests/Index/TestForceMergeForever.cs
@@ -97,7 +97,7 @@ namespace Lucene.Net.Index
AtomicBoolean doStop = new AtomicBoolean();
w.Config.SetMaxBufferedDocs(2);
- ThreadJob t = new ThreadAnonymousInnerClassHelper(this, w, numStartDocs, docs, doStop);
+ ThreadJob t = new ThreadAnonymousClass(this, w, numStartDocs, docs, doStop);
t.Start();
w.ForceMerge(1);
doStop.Value = true;
@@ -108,7 +108,7 @@ namespace Lucene.Net.Index
docs.Dispose();
}
- private class ThreadAnonymousInnerClassHelper : ThreadJob
+ private class ThreadAnonymousClass : ThreadJob
{
private readonly TestForceMergeForever outerInstance;
@@ -117,7 +117,7 @@ namespace Lucene.Net.Index
private readonly LineFileDocs docs;
private readonly AtomicBoolean doStop;
- public ThreadAnonymousInnerClassHelper(TestForceMergeForever outerInstance, Lucene.Net.Index.TestForceMergeForever.MyIndexWriter w, int numStartDocs, LineFileDocs docs, AtomicBoolean doStop)
+ public ThreadAnonymousClass(TestForceMergeForever outerInstance, Lucene.Net.Index.TestForceMergeForever.MyIndexWriter w, int numStartDocs, LineFileDocs docs, AtomicBoolean doStop)
{
this.outerInstance = outerInstance;
this.w = w;
diff --git a/src/Lucene.Net.Tests/Index/TestIndexCommit.cs b/src/Lucene.Net.Tests/Index/TestIndexCommit.cs
index bde46f3..95bec68 100644
--- a/src/Lucene.Net.Tests/Index/TestIndexCommit.cs
+++ b/src/Lucene.Net.Tests/Index/TestIndexCommit.cs
@@ -33,22 +33,22 @@ namespace Lucene.Net.Index
// LUCENE-2417: equals and hashCode() impl was inconsistent
Directory dir = NewDirectory();
- IndexCommit ic1 = new IndexCommitAnonymousInnerClassHelper(this, dir);
+ IndexCommit ic1 = new IndexCommitAnonymousClass(this, dir);
- IndexCommit ic2 = new IndexCommitAnonymousInnerClassHelper2(this, dir);
+ IndexCommit ic2 = new IndexCommitAnonymousClass2(this, dir);
Assert.AreEqual(ic1, ic2);
Assert.AreEqual(ic1.GetHashCode(), ic2.GetHashCode(), "hash codes are not equals");
dir.Dispose();
}
- private class IndexCommitAnonymousInnerClassHelper : IndexCommit
+ private class IndexCommitAnonymousClass : IndexCommit
{
private readonly TestIndexCommit outerInstance;
private Directory dir;
- public IndexCommitAnonymousInnerClassHelper(TestIndexCommit outerInstance, Directory dir)
+ public IndexCommitAnonymousClass(TestIndexCommit outerInstance, Directory dir)
{
this.outerInstance = outerInstance;
this.dir = dir;
@@ -73,13 +73,13 @@ namespace Lucene.Net.Index
public override int SegmentCount => 2;
}
- private class IndexCommitAnonymousInnerClassHelper2 : IndexCommit
+ private class IndexCommitAnonymousClass2 : IndexCommit
{
private readonly TestIndexCommit outerInstance;
private Directory dir;
- public IndexCommitAnonymousInnerClassHelper2(TestIndexCommit outerInstance, Directory dir)
+ public IndexCommitAnonymousClass2(TestIndexCommit outerInstance, Directory dir)
{
this.outerInstance = outerInstance;
this.dir = dir;
diff --git a/src/Lucene.Net.Tests/Index/TestIndexReaderClose.cs b/src/Lucene.Net.Tests/Index/TestIndexReaderClose.cs
index 0a50168..57c52af 100644
--- a/src/Lucene.Net.Tests/Index/TestIndexReaderClose.cs
+++ b/src/Lucene.Net.Tests/Index/TestIndexReaderClose.cs
@@ -44,7 +44,7 @@ namespace Lucene.Net.Index
DirectoryReader open = DirectoryReader.Open(dir);
bool throwOnClose = !Rarely();
AtomicReader wrap = SlowCompositeReaderWrapper.Wrap(open);
- FilterAtomicReader reader = new FilterAtomicReaderAnonymousInnerClassHelper(this, wrap, throwOnClose);
+ FilterAtomicReader reader = new FilterAtomicReaderAnonymousClass(this, wrap, throwOnClose);
IList<IndexReader.IReaderClosedListener> listeners = new List<IndexReader.IReaderClosedListener>();
int listenerCount = Random.Next(20);
AtomicInt32 count = new AtomicInt32();
@@ -104,13 +104,13 @@ namespace Lucene.Net.Index
}
}
- private class FilterAtomicReaderAnonymousInnerClassHelper : FilterAtomicReader
+ private class FilterAtomicReaderAnonymousClass : FilterAtomicReader
{
private readonly TestIndexReaderClose outerInstance;
private bool throwOnClose;
- public FilterAtomicReaderAnonymousInnerClassHelper(TestIndexReaderClose outerInstance, AtomicReader wrap, bool throwOnClose)
+ public FilterAtomicReaderAnonymousClass(TestIndexReaderClose outerInstance, AtomicReader wrap, bool throwOnClose)
: base(wrap)
{
this.outerInstance = outerInstance;
diff --git a/src/Lucene.Net.Tests/Index/TestIndexWriter.cs b/src/Lucene.Net.Tests/Index/TestIndexWriter.cs
index cd80f74..2303bdd 100644
--- a/src/Lucene.Net.Tests/Index/TestIndexWriter.cs
+++ b/src/Lucene.Net.Tests/Index/TestIndexWriter.cs
@@ -1019,7 +1019,7 @@ namespace Lucene.Net.Index
[Test]
public virtual void TestNegativePositions()
{
- TokenStream tokens = new TokenStreamAnonymousInnerClassHelper(this);
+ TokenStream tokens = new TokenStreamAnonymousClass(this);
Directory dir = NewDirectory();
IndexWriter w = new IndexWriter(dir, NewIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(Random)));
@@ -1040,11 +1040,11 @@ namespace Lucene.Net.Index
dir.Dispose();
}
- private class TokenStreamAnonymousInnerClassHelper : TokenStream
+ private class TokenStreamAnonymousClass : TokenStream
{
private readonly TestIndexWriter outerInstance;
- public TokenStreamAnonymousInnerClassHelper(TestIndexWriter outerInstance)
+ public TokenStreamAnonymousClass(TestIndexWriter outerInstance)
{
this.outerInstance = outerInstance;
termAtt = AddAttribute<ICharTermAttribute>();
@@ -2282,7 +2282,7 @@ namespace Lucene.Net.Index
[Test]
public virtual void TestDontInvokeAnalyzerForUnAnalyzedFields()
{
- Analyzer analyzer = new AnalyzerAnonymousInnerClassHelper(this);
+ Analyzer analyzer = new AnalyzerAnonymousClass(this);
Directory dir = NewDirectory();
IndexWriter w = new IndexWriter(dir, NewIndexWriterConfig(TEST_VERSION_CURRENT, analyzer));
Document doc = new Document();
@@ -2301,11 +2301,11 @@ namespace Lucene.Net.Index
dir.Dispose();
}
- private class AnalyzerAnonymousInnerClassHelper : Analyzer
+ private class AnalyzerAnonymousClass : Analyzer
{
private readonly TestIndexWriter outerInstance;
- public AnalyzerAnonymousInnerClassHelper(TestIndexWriter outerInstance)
+ public AnalyzerAnonymousClass(TestIndexWriter outerInstance)
{
this.outerInstance = outerInstance;
}
@@ -2645,7 +2645,7 @@ namespace Lucene.Net.Index
public virtual IEnumerator<IEnumerable<IIndexableField>> GetEnumerator()
{
return docList.GetEnumerator();
- //return new IteratorAnonymousInnerClassHelper(this, docIter);
+ //return new IteratorAnonymousClass(this, docIter);
}
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
@@ -2654,13 +2654,13 @@ namespace Lucene.Net.Index
}
/*
- private class IteratorAnonymousInnerClassHelper : IEnumerator<IEnumerable<IndexableField>>
+ private class IteratorAnonymousClass : IEnumerator<IEnumerable<IndexableField>>
{
private readonly RandomFailingFieldIterable outerInstance;
private IEnumerator<IEnumerable<IndexableField>> DocIter;
- public IteratorAnonymousInnerClassHelper(RandomFailingFieldIterable outerInstance, IEnumerator<IEnumerable<IndexableField>> docIter)
+ public IteratorAnonymousClass(RandomFailingFieldIterable outerInstance, IEnumerator<IEnumerable<IndexableField>> docIter)
{
this.outerInstance = outerInstance;
this.DocIter = docIter;
@@ -2811,7 +2811,7 @@ namespace Lucene.Net.Index
Directory dir = NewDirectory();
IndexWriterConfig iwc = NewIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(Random));
SetOnce<IndexWriter> iwRef = new SetOnce<IndexWriter>();
- iwc.SetInfoStream(new TestPointInfoStream(iwc.InfoStream, new TestPointAnonymousInnerClassHelper(this, iwRef)));
+ iwc.SetInfoStream(new TestPointInfoStream(iwc.InfoStream, new TestPointAnonymousClass(this, iwRef)));
IndexWriter evilWriter = new IndexWriter(dir, iwc);
iwRef.Set(evilWriter);
for (int i = 0; i < 1000; i++)
@@ -2828,13 +2828,13 @@ namespace Lucene.Net.Index
dir.Dispose();
}
- private class TestPointAnonymousInnerClassHelper : ITestPoint
+ private class TestPointAnonymousClass : ITestPoint
{
private readonly TestIndexWriter outerInstance;
private SetOnce<IndexWriter> iwRef;
- public TestPointAnonymousInnerClassHelper(TestIndexWriter outerInstance, SetOnce<IndexWriter> iwRef)
+ public TestPointAnonymousClass(TestIndexWriter outerInstance, SetOnce<IndexWriter> iwRef)
{
this.outerInstance = outerInstance;
this.iwRef = iwRef;
diff --git a/src/Lucene.Net.Tests/Index/TestIndexWriterCommit.cs b/src/Lucene.Net.Tests/Index/TestIndexWriterCommit.cs
index 2b7a16a..33155f1 100644
--- a/src/Lucene.Net.Tests/Index/TestIndexWriterCommit.cs
+++ b/src/Lucene.Net.Tests/Index/TestIndexWriterCommit.cs
@@ -346,7 +346,7 @@ namespace Lucene.Net.Index
for (int i = 0; i < NUM_THREADS; i++)
{
int finalI = i;
- threads[i] = new ThreadAnonymousInnerClassHelper(dir, w, failed, endTime, finalI, NewStringField);
+ threads[i] = new ThreadAnonymousClass(dir, w, failed, endTime, finalI, NewStringField);
threads[i].Start();
}
for (int i = 0; i < NUM_THREADS; i++)
@@ -358,7 +358,7 @@ namespace Lucene.Net.Index
dir.Dispose();
}
- private class ThreadAnonymousInnerClassHelper : ThreadJob
+ private class ThreadAnonymousClass : ThreadJob
{
private readonly Func<string, string, Field.Store, Field> newStringField;
private Directory dir;
@@ -372,7 +372,7 @@ namespace Lucene.Net.Index
/// This is passed in because <see cref="LuceneTestCase.NewStringField(string, string, Field.Store)"/>
/// is no longer static.
/// </param>
- public ThreadAnonymousInnerClassHelper(Directory dir, RandomIndexWriter w, AtomicBoolean failed, long endTime, int finalI, Func<string, string, Field.Store, Field> newStringField)
+ public ThreadAnonymousClass(Directory dir, RandomIndexWriter w, AtomicBoolean failed, long endTime, int finalI, Func<string, string, Field.Store, Field> newStringField)
{
this.newStringField = newStringField;
this.dir = dir;
diff --git a/src/Lucene.Net.Tests/Index/TestIndexWriterDelete.cs b/src/Lucene.Net.Tests/Index/TestIndexWriterDelete.cs
index 8ab55c3..3f38404 100644
--- a/src/Lucene.Net.Tests/Index/TestIndexWriterDelete.cs
+++ b/src/Lucene.Net.Tests/Index/TestIndexWriterDelete.cs
@@ -349,7 +349,7 @@ namespace Lucene.Net.Index
for (int i = 0; i < numThreads; i++)
{
int offset = i;
- threads[i] = new ThreadAnonymousInnerClassHelper(this, modifier, latch, doneLatch, offset);
+ threads[i] = new ThreadAnonymousClass(this, modifier, latch, doneLatch, offset);
threads[i].Start();
}
latch.Signal();
@@ -379,7 +379,7 @@ namespace Lucene.Net.Index
dir.Dispose();
}
- private class ThreadAnonymousInnerClassHelper : ThreadJob
+ private class ThreadAnonymousClass : ThreadJob
{
private readonly TestIndexWriterDelete outerInstance;
@@ -388,7 +388,7 @@ namespace Lucene.Net.Index
private readonly CountdownEvent doneLatch;
private readonly int offset;
- public ThreadAnonymousInnerClassHelper(TestIndexWriterDelete outerInstance, RandomIndexWriter modifier, CountdownEvent latch, CountdownEvent doneLatch, int offset)
+ public ThreadAnonymousClass(TestIndexWriterDelete outerInstance, RandomIndexWriter modifier, CountdownEvent latch, CountdownEvent doneLatch, int offset)
{
this.outerInstance = outerInstance;
this.modifier = modifier;
@@ -828,7 +828,7 @@ namespace Lucene.Net.Index
[Test]
public virtual void TestErrorAfterApplyDeletes()
{
- Failure failure = new FailureAnonymousInnerClassHelper(this);
+ Failure failure = new FailureAnonymousClass(this);
// create a couple of files
@@ -943,11 +943,11 @@ namespace Lucene.Net.Index
dir.Dispose();
}
- private class FailureAnonymousInnerClassHelper : Failure
+ private class FailureAnonymousClass : Failure
{
private readonly TestIndexWriterDelete outerInstance;
- public FailureAnonymousInnerClassHelper(TestIndexWriterDelete outerInstance)
+ public FailureAnonymousClass(TestIndexWriterDelete outerInstance)
{
this.outerInstance = outerInstance;
sawMaybe = false;
@@ -1015,7 +1015,7 @@ namespace Lucene.Net.Index
[Test]
public virtual void TestErrorInDocsWriterAdd()
{
- Failure failure = new FailureAnonymousInnerClassHelper2(this);
+ Failure failure = new FailureAnonymousClass2(this);
// create a couple of files
@@ -1058,11 +1058,11 @@ namespace Lucene.Net.Index
dir.Dispose();
}
- private class FailureAnonymousInnerClassHelper2 : Failure
+ private class FailureAnonymousClass2 : Failure
{
private readonly TestIndexWriterDelete outerInstance;
- public FailureAnonymousInnerClassHelper2(TestIndexWriterDelete outerInstance)
+ public FailureAnonymousClass2(TestIndexWriterDelete outerInstance)
{
this.outerInstance = outerInstance;
failed = false;
@@ -1312,7 +1312,7 @@ namespace Lucene.Net.Index
AtomicInt32 docsInSegment = new AtomicInt32();
AtomicBoolean closing = new AtomicBoolean();
AtomicBoolean sawAfterFlush = new AtomicBoolean();
- IndexWriter w = new IndexWriterAnonymousInnerClassHelper(this, dir, NewIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(Random)).SetRAMBufferSizeMB(0.5).SetMaxBufferedDocs(-1).SetMergePolicy(NoMergePolicy.NO_COMPOUND_FILES).SetReaderPooling(false), docsInSegment, closing, sawAfterFlush);
+ IndexWriter w = new IndexWriterAnonymousClass(this, dir, NewIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(Random)).SetRAMBufferSizeMB(0.5).SetMaxBufferedDocs(-1).SetMergePolicy(NoMergePolicy.NO_COMPOUND_FILES).SetReaderPooling(false), docsInSegment, closing, sawAfterFlush);
int id = 0;
while (true)
{
@@ -1347,7 +1347,7 @@ namespace Lucene.Net.Index
dir.Dispose();
}
- private class IndexWriterAnonymousInnerClassHelper : IndexWriter
+ private class IndexWriterAnonymousClass : IndexWriter
{
private readonly TestIndexWriterDelete outerInstance;
@@ -1355,7 +1355,7 @@ namespace Lucene.Net.Index
private readonly AtomicBoolean closing;
private readonly AtomicBoolean sawAfterFlush;
- public IndexWriterAnonymousInnerClassHelper(TestIndexWriterDelete outerInstance, Directory dir, IndexWriterConfig setReaderPooling, AtomicInt32 docsInSegment, AtomicBoolean closing, AtomicBoolean sawAfterFlush)
+ public IndexWriterAnonymousClass(TestIndexWriterDelete outerInstance, Directory dir, IndexWriterConfig setReaderPooling, AtomicInt32 docsInSegment, AtomicBoolean closing, AtomicBoolean sawAfterFlush)
: base(dir, setReaderPooling)
{
this.outerInstance = outerInstance;
diff --git a/src/Lucene.Net.Tests/Index/TestIndexWriterExceptions.cs b/src/Lucene.Net.Tests/Index/TestIndexWriterExceptions.cs
index 41f6a11..f82f31e 100644
--- a/src/Lucene.Net.Tests/Index/TestIndexWriterExceptions.cs
+++ b/src/Lucene.Net.Tests/Index/TestIndexWriterExceptions.cs
@@ -113,7 +113,7 @@ namespace Lucene.Net.Index
public virtual IEnumerator<Document> GetEnumerator()
{
- return new IteratorAnonymousInnerClassHelper(this);
+ return new IteratorAnonymousClass(this);
}
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
@@ -121,11 +121,11 @@ namespace Lucene.Net.Index
return GetEnumerator();
}
- private class IteratorAnonymousInnerClassHelper : IEnumerator<Document>
+ private class IteratorAnonymousClass : IEnumerator<Document>
{
private readonly DocCopyIterator outerInstance;
- public IteratorAnonymousInnerClassHelper(DocCopyIterator outerInstance)
+ public IteratorAnonymousClass(DocCopyIterator outerInstance)
{
this.outerInstance = outerInstance;
}
@@ -603,7 +603,7 @@ namespace Lucene.Net.Index
{
MockTokenizer tokenizer = new MockTokenizer(reader2, MockTokenizer.SIMPLE, true);
tokenizer.EnableChecks = false; // disable workflow checking as we forcefully close() in exceptional cases.
- return new TokenStreamComponents(tokenizer, new TokenFilterAnonymousInnerClassHelper(tokenizer));
+ return new TokenStreamComponents(tokenizer, new TokenFilterAnonymousClass(tokenizer));
});
IndexWriterConfig conf = NewIndexWriterConfig(TEST_VERSION_CURRENT, analyzer);
@@ -656,9 +656,9 @@ namespace Lucene.Net.Index
dir.Dispose();
}
- private class TokenFilterAnonymousInnerClassHelper : TokenFilter
+ private class TokenFilterAnonymousClass : TokenFilter
{
- public TokenFilterAnonymousInnerClassHelper(MockTokenizer tokenizer)
+ public TokenFilterAnonymousClass(MockTokenizer tokenizer)
: base(tokenizer)
{
count = 0;
@@ -888,7 +888,7 @@ namespace Lucene.Net.Index
ThreadJob[] threads = new ThreadJob[NUM_THREAD];
for (int t = 0; t < NUM_THREAD; t++)
{
- threads[t] = new ThreadAnonymousInnerClassHelper(NUM_ITER, writer, finalI);
+ threads[t] = new ThreadAnonymousClass(NUM_ITER, writer, finalI);
threads[t].Start();
}
@@ -949,13 +949,13 @@ namespace Lucene.Net.Index
}
}
- private class ThreadAnonymousInnerClassHelper : ThreadJob
+ private class ThreadAnonymousClass : ThreadJob
{
private readonly int NUM_ITER;
private readonly IndexWriter writer;
private readonly int finalI;
- public ThreadAnonymousInnerClassHelper(int NUM_ITER, IndexWriter writer, int finalI)
+ public ThreadAnonymousClass(int NUM_ITER, IndexWriter writer, int finalI)
{
this.NUM_ITER = NUM_ITER;
this.writer = writer;
@@ -1221,7 +1221,7 @@ namespace Lucene.Net.Index
{
AtomicBoolean thrown = new AtomicBoolean(false);
Directory dir = NewDirectory();
- IndexWriter writer = new IndexWriter(dir, NewIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(Random)).SetInfoStream(new TOOMInfoStreamAnonymousInnerClassHelper(thrown)));
+ IndexWriter writer = new IndexWriter(dir, NewIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(Random)).SetInfoStream(new TOOMInfoStreamAnonymousClass(thrown)));
try
{
@@ -1239,11 +1239,11 @@ namespace Lucene.Net.Index
dir.Dispose();
}
- private class TOOMInfoStreamAnonymousInnerClassHelper : InfoStream
+ private class TOOMInfoStreamAnonymousClass : InfoStream
{
private readonly AtomicBoolean thrown;
- public TOOMInfoStreamAnonymousInnerClassHelper(AtomicBoolean thrown)
+ public TOOMInfoStreamAnonymousClass(AtomicBoolean thrown)
{
this.thrown = thrown;
}
@@ -1916,7 +1916,7 @@ namespace Lucene.Net.Index
doc = new Document();
// try to boost with norms omitted
IList<IIndexableField> list = new List<IIndexableField>();
- list.Add(new IndexableFieldAnonymousInnerClassHelper());
+ list.Add(new IndexableFieldAnonymousClass());
iw.AddDocument(list);
Assert.Fail("didn't get any exception, boost silently discarded");
}
@@ -1934,7 +1934,7 @@ namespace Lucene.Net.Index
dir.Dispose();
}
- private class IndexableFieldAnonymousInnerClassHelper : IIndexableField
+ private class IndexableFieldAnonymousClass : IIndexableField
{
public string Name => "foo";
@@ -2032,7 +2032,7 @@ namespace Lucene.Net.Index
public virtual void TestTooManyFileException()
{
// Create failure that throws Too many open files exception randomly
- Failure failure = new FailureAnonymousInnerClassHelper();
+ Failure failure = new FailureAnonymousClass();
MockDirectoryWrapper dir = NewMockDirectory();
// The exception is only thrown on open input
@@ -2095,7 +2095,7 @@ namespace Lucene.Net.Index
dir.Dispose();
}
- private class FailureAnonymousInnerClassHelper : Failure
+ private class FailureAnonymousClass : Failure
{
public override Failure Reset()
@@ -2129,7 +2129,7 @@ namespace Lucene.Net.Index
MockDirectoryWrapper dir = NewMockDirectory();
AtomicBoolean shouldFail = new AtomicBoolean();
- dir.FailOn(new FailureAnonymousInnerClassHelper2(shouldFail));
+ dir.FailOn(new FailureAnonymousClass2(shouldFail));
RandomIndexWriter w = null;
@@ -2146,7 +2146,7 @@ namespace Lucene.Net.Index
IMergeScheduler ms = iwc.MergeScheduler;
if (ms is IConcurrentMergeScheduler)
{
- IConcurrentMergeScheduler suppressFakeIOE = new ConcurrentMergeSchedulerAnonymousInnerClassHelper();
+ IConcurrentMergeScheduler suppressFakeIOE = new ConcurrentMergeSchedulerAnonymousClass();
IConcurrentMergeScheduler cms = (IConcurrentMergeScheduler)ms;
suppressFakeIOE.SetMaxMergesAndThreads(cms.MaxMergeCount, cms.MaxThreadCount);
@@ -2357,11 +2357,11 @@ namespace Lucene.Net.Index
dir.Dispose();
}
- private class FailureAnonymousInnerClassHelper2 : Failure
+ private class FailureAnonymousClass2 : Failure
{
private readonly AtomicBoolean shouldFail;
- public FailureAnonymousInnerClassHelper2(AtomicBoolean shouldFail)
+ public FailureAnonymousClass2(AtomicBoolean shouldFail)
{
this.shouldFail = shouldFail;
}
@@ -2397,7 +2397,7 @@ namespace Lucene.Net.Index
}
}
- private class ConcurrentMergeSchedulerAnonymousInnerClassHelper : ConcurrentMergeScheduler
+ private class ConcurrentMergeSchedulerAnonymousClass : ConcurrentMergeScheduler
{
protected override void HandleMergeException(Exception exc)
{
@@ -2419,7 +2419,7 @@ namespace Lucene.Net.Index
string messageToFailOn = Random.NextBoolean() ? "rollback: done finish merges" : "rollback before checkpoint";
// infostream that throws exception during rollback
- InfoStream evilInfoStream = new TEDRInfoStreamAnonymousInnerClassHelper(messageToFailOn);
+ InfoStream evilInfoStream = new TEDRInfoStreamAnonymousClass(messageToFailOn);
Directory dir = NewMockDirectory(); // we want to ensure we don't leak any locks or file handles
IndexWriterConfig iwc = new IndexWriterConfig(TEST_VERSION_CURRENT, null);
@@ -2467,11 +2467,11 @@ namespace Lucene.Net.Index
dir.Dispose();
}
- private class TEDRInfoStreamAnonymousInnerClassHelper : InfoStream
+ private class TEDRInfoStreamAnonymousClass : InfoStream
{
private readonly string messageToFailOn;
- public TEDRInfoStreamAnonymousInnerClassHelper(string messageToFailOn)
+ public TEDRInfoStreamAnonymousClass(string messageToFailOn)
{
this.messageToFailOn = messageToFailOn;
}
@@ -2505,7 +2505,7 @@ namespace Lucene.Net.Index
for (int iter = 0; iter < numIters; iter++)
{
MockDirectoryWrapper dir = NewMockDirectory();
- dir.FailOn(new FailureAnonymousInnerClassHelper3());
+ dir.FailOn(new FailureAnonymousClass3());
IndexWriterConfig iwc = new IndexWriterConfig(TEST_VERSION_CURRENT, null);
IndexWriter iw = new IndexWriter(dir, iwc);
@@ -2552,7 +2552,7 @@ namespace Lucene.Net.Index
}
}
- private class FailureAnonymousInnerClassHelper3 : Failure
+ private class FailureAnonymousClass3 : Failure
{
public override void Eval(MockDirectoryWrapper dir)
{
diff --git a/src/Lucene.Net.Tests/Index/TestIndexWriterMerging.cs b/src/Lucene.Net.Tests/Index/TestIndexWriterMerging.cs
index eee2d87..c925740 100644
--- a/src/Lucene.Net.Tests/Index/TestIndexWriterMerging.cs
+++ b/src/Lucene.Net.Tests/Index/TestIndexWriterMerging.cs
@@ -405,7 +405,7 @@ namespace Lucene.Net.Index
IndexWriter finalWriter = writer;
List<Exception> failure = new List<Exception>();
- ThreadJob t1 = new ThreadAnonymousInnerClassHelper(this, doc, finalWriter, failure);
+ ThreadJob t1 = new ThreadAnonymousClass(this, doc, finalWriter, failure);
if (failure.Count > 0)
{
@@ -430,7 +430,7 @@ namespace Lucene.Net.Index
directory.Dispose();
}
- private class ThreadAnonymousInnerClassHelper : ThreadJob
+ private class ThreadAnonymousClass : ThreadJob
{
private readonly TestIndexWriterMerging outerInstance;
@@ -438,7 +438,7 @@ namespace Lucene.Net.Index
private IndexWriter finalWriter;
private List<Exception> failure;
- public ThreadAnonymousInnerClassHelper(TestIndexWriterMerging outerInstance, Document doc, IndexWriter finalWriter, List<Exception> failure)
+ public ThreadAnonymousClass(TestIndexWriterMerging outerInstance, Document doc, IndexWriter finalWriter, List<Exception> failure)
{
this.outerInstance = outerInstance;
this.doc = doc;
diff --git a/src/Lucene.Net.Tests/Index/TestIndexWriterOnJRECrash.cs b/src/Lucene.Net.Tests/Index/TestIndexWriterOnJRECrash.cs
index b5250eb..c6b3ca9 100644
--- a/src/Lucene.Net.Tests/Index/TestIndexWriterOnJRECrash.cs
+++ b/src/Lucene.Net.Tests/Index/TestIndexWriterOnJRECrash.cs
@@ -79,7 +79,7 @@
// AssumeFalse("does not support PreFlex, see LUCENE-3992", Codec.Default.Name.Equals("Lucene3x", StringComparison.Ordinal));
// // we are the fork, setup a crashing thread
// int crashTime = TestUtil.NextInt(Random(), 3000, 4000);
-// ThreadClass t = new ThreadAnonymousInnerClassHelper(this, crashTime);
+// ThreadClass t = new ThreadAnonymousClass(this, crashTime);
// t.Priority = ThreadPriority.Highest;
// t.Start();
// // run the test until we crash.
@@ -90,13 +90,13 @@
// }
// }
-// private class ThreadAnonymousInnerClassHelper : ThreadClass
+// private class ThreadAnonymousClass : ThreadClass
// {
// private readonly TestIndexWriterOnJRECrash outerInstance;
// private int CrashTime;
-// public ThreadAnonymousInnerClassHelper(TestIndexWriterOnJRECrash outerInstance, int crashTime)
+// public ThreadAnonymousClass(TestIndexWriterOnJRECrash outerInstance, int crashTime)
// {
// this.outerInstance = outerInstance;
// this.CrashTime = crashTime;
@@ -160,17 +160,17 @@
// {
// public static Thread Start(InputStream from, OutputStream to)
// {
-// ThreadClass t = new ThreadAnonymousInnerClassHelper2(from, to);
+// ThreadClass t = new ThreadAnonymousClass2(from, to);
// t.Start();
// return t;
// }
-// private class ThreadAnonymousInnerClassHelper2 : ThreadClass
+// private class ThreadAnonymousClass2 : ThreadClass
// {
// private InputStream From;
// private OutputStream To;
-// public ThreadAnonymousInnerClassHelper2(InputStream from, OutputStream to)
+// public ThreadAnonymousClass2(InputStream from, OutputStream to)
// {
// this.From = from;
// this.To = to;
diff --git a/src/Lucene.Net.Tests/Index/TestIndexWriterReader.cs b/src/Lucene.Net.Tests/Index/TestIndexWriterReader.cs
index cc4a9eb..3743e0f 100644
--- a/src/Lucene.Net.Tests/Index/TestIndexWriterReader.cs
+++ b/src/Lucene.Net.Tests/Index/TestIndexWriterReader.cs
@@ -555,7 +555,7 @@ namespace Lucene.Net.Index
{
for (int i = 0; i < outerInstance.numThreads; i++)
{
- threads[i] = new ThreadAnonymousInnerClassHelper(this, numIter);
+ threads[i] = new ThreadAnonymousClass(this, numIter);
}
for (int i = 0; i < outerInstance.numThreads; i++)
{
@@ -563,13 +563,13 @@ namespace Lucene.Net.Index
}
}
- private class ThreadAnonymousInnerClassHelper : ThreadJob
+ private class ThreadAnonymousClass : ThreadJob
{
private readonly AddDirectoriesThreads outerInstance;
private readonly int numIter;
- public ThreadAnonymousInnerClassHelper(AddDirectoriesThreads outerInstance, int numIter)
+ public ThreadAnonymousClass(AddDirectoriesThreads outerInstance, int numIter)
{
this.outerInstance = outerInstance;
this.numIter = numIter;
@@ -899,7 +899,7 @@ namespace Lucene.Net.Index
var threads = new ThreadJob[1];
for (int i = 0; i < threads.Length; i++)
{
- threads[i] = new ThreadAnonymousInnerClassHelper(writer, dirs, endTime, excs);
+ threads[i] = new ThreadAnonymousClass(writer, dirs, endTime, excs);
threads[i].IsBackground = (true);
threads[i].Start();
}
@@ -949,14 +949,14 @@ namespace Lucene.Net.Index
dir1.Dispose();
}
- private class ThreadAnonymousInnerClassHelper : ThreadJob
+ private class ThreadAnonymousClass : ThreadJob
{
private readonly IndexWriter writer;
private readonly Directory[] dirs;
private readonly long endTime;
private readonly ConcurrentQueue<Exception> excs;
- public ThreadAnonymousInnerClassHelper(IndexWriter writer, Directory[] dirs, long endTime, ConcurrentQueue<Exception> excs)
+ public ThreadAnonymousClass(IndexWriter writer, Directory[] dirs, long endTime, ConcurrentQueue<Exception> excs)
{
this.writer = writer;
this.dirs = dirs;
@@ -1013,7 +1013,7 @@ namespace Lucene.Net.Index
var threads = new ThreadJob[numThreads];
for (int i = 0; i < numThreads; i++)
{
- threads[i] = new ThreadAnonymousInnerClassHelper2(writer, endTime, excs);
+ threads[i] = new ThreadAnonymousClass2(writer, endTime, excs);
threads[i].IsBackground = (true);
threads[i].Start();
}
@@ -1055,13 +1055,13 @@ namespace Lucene.Net.Index
dir1.Dispose();
}
- private class ThreadAnonymousInnerClassHelper2 : ThreadJob
+ private class ThreadAnonymousClass2 : ThreadJob
{
private readonly IndexWriter writer;
private readonly long endTime;
private readonly ConcurrentQueue<Exception> excs;
- public ThreadAnonymousInnerClassHelper2(IndexWriter writer, long endTime, ConcurrentQueue<Exception> excs)
+ public ThreadAnonymousClass2(IndexWriter writer, long endTime, ConcurrentQueue<Exception> excs)
{
this.writer = writer;
this.endTime = endTime;
@@ -1174,7 +1174,7 @@ namespace Lucene.Net.Index
{
Directory dir = NewDirectory();
AtomicBoolean didWarm = new AtomicBoolean();
- IndexWriter w = new IndexWriter(dir, NewIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(Random)).SetMaxBufferedDocs(2).SetReaderPooling(true).SetMergedSegmentWarmer(new IndexReaderWarmerAnonymousInnerClassHelper(didWarm)).
+ IndexWriter w = new IndexWriter(dir, NewIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(Random)).SetMaxBufferedDocs(2).SetReaderPooling(true).SetMergedSegmentWarmer(new IndexReaderWarmerAnonymousClass(didWarm)).
SetMergePolicy(NewLogMergePolicy(10)));
Document doc = new Document();
@@ -1189,11 +1189,11 @@ namespace Lucene.Net.Index
Assert.IsTrue(didWarm);
}
- private class IndexReaderWarmerAnonymousInnerClassHelper : IndexWriter.IndexReaderWarmer
+ private class IndexReaderWarmerAnonymousClass : IndexWriter.IndexReaderWarmer
{
private readonly AtomicBoolean didWarm;
- public IndexReaderWarmerAnonymousInnerClassHelper(AtomicBoolean didWarm)
+ public IndexReaderWarmerAnonymousClass(AtomicBoolean didWarm)
{
this.didWarm = didWarm;
}
@@ -1216,7 +1216,7 @@ namespace Lucene.Net.Index
{
Directory dir = NewDirectory();
AtomicBoolean didWarm = new AtomicBoolean();
- InfoStream infoStream = new InfoStreamAnonymousInnerClassHelper(didWarm);
+ InfoStream infoStream = new InfoStreamAnonymousClass(didWarm);
IndexWriter w = new IndexWriter(dir, NewIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(Random)).SetMaxBufferedDocs(2).SetReaderPooling(true).SetInfoStream(infoStream).SetMergedSegmentWarmer(new SimpleMergedSegmentWarmer(infoStream)).SetMergePolicy(NewLogMergePolicy(10)));
Document doc = new Document();
@@ -1231,11 +1231,11 @@ namespace Lucene.Net.Index
Assert.IsTrue(didWarm);
}
- private class InfoStreamAnonymousInnerClassHelper : InfoStream
+ private class InfoStreamAnonymousClass : InfoStream
{
private readonly AtomicBoolean didWarm;
- public InfoStreamAnonymousInnerClassHelper(AtomicBoolean didWarm)
+ public InfoStreamAnonymousClass(AtomicBoolean didWarm)
{
this.didWarm = didWarm;
}
@@ -1347,7 +1347,7 @@ namespace Lucene.Net.Index
// don't leak file handles.
MockDirectoryWrapper dir = (MockDirectoryWrapper)GetAssertNoDeletesDirectory(NewMockDirectory());
AtomicBoolean shouldFail = new AtomicBoolean();
- dir.FailOn(new FailureAnonymousInnerClassHelper(shouldFail));
+ dir.FailOn(new FailureAnonymousClass(shouldFail));
IndexWriterConfig conf = NewIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(Random));
conf.SetMergePolicy(NoMergePolicy.COMPOUND_FILES); // prevent merges from getting in the way
@@ -1386,11 +1386,11 @@ namespace Lucene.Net.Index
dir.Dispose();
}
- private class FailureAnonymousInnerClassHelper : Failure
+ private class FailureAnonymousClass : Failure
{
private readonly AtomicBoolean shouldFail;
- public FailureAnonymousInnerClassHelper(AtomicBoolean shouldFail)
+ public FailureAnonymousClass(AtomicBoolean shouldFail)
{
this.shouldFail = shouldFail;
}
diff --git a/src/Lucene.Net.Tests/Index/TestIndexWriterWithThreads.cs b/src/Lucene.Net.Tests/Index/TestIndexWriterWithThreads.cs
index 342f2d9..e3e973a 100644
--- a/src/Lucene.Net.Tests/Index/TestIndexWriterWithThreads.cs
+++ b/src/Lucene.Net.Tests/Index/TestIndexWriterWithThreads.cs
@@ -683,7 +683,7 @@ namespace Lucene.Net.Index
ReentrantLock commitLock = new ReentrantLock();
for (int threadID = 0; threadID < threadCount; threadID++)
{
- threads[threadID] = new ThreadAnonymousInnerClassHelper(this, d, writerRef, docs, iters, failed, rollbackLock, commitLock);
+ threads[threadID] = new ThreadAnonymousClass(this, d, writerRef, docs, iters, failed, rollbackLock, commitLock);
threads[threadID].Start();
}
@@ -695,7 +695,7 @@ namespace Lucene.Net.Index
}
catch (Exception e)
{
- Console.WriteLine("EXCEPTION in ThreadAnonymousInnerClassHelper: " + Environment.NewLine + e);
+ Console.WriteLine("EXCEPTION in ThreadAnonymousClass: " + Environment.NewLine + e);
}
}
@@ -704,7 +704,7 @@ namespace Lucene.Net.Index
d.Dispose();
}
- private class ThreadAnonymousInnerClassHelper : ThreadJob
+ private class ThreadAnonymousClass : ThreadJob
{
#if FEATURE_INSTANCE_TESTDATA_INITIALIZATION
private readonly TestIndexWriterWithThreads outerInstance;
@@ -718,7 +718,7 @@ namespace Lucene.Net.Index
private readonly ReentrantLock rollbackLock;
private readonly ReentrantLock commitLock;
- public ThreadAnonymousInnerClassHelper(TestIndexWriterWithThreads outerInstance, BaseDirectoryWrapper d, AtomicReference<IndexWriter> writerRef, LineFileDocs docs, int iters, AtomicBoolean failed, ReentrantLock rollbackLock, ReentrantLock commitLock)
+ public ThreadAnonymousClass(TestIndexWriterWithThreads outerInstance, BaseDirectoryWrapper d, AtomicReference<IndexWriter> writerRef, LineFileDocs docs, int iters, AtomicBoolean failed, ReentrantLock rollbackLock, ReentrantLock commitLock)
{
#if FEATURE_INSTANCE_TESTDATA_INITIALIZATION
this.outerInstance = outerInstance;
diff --git a/src/Lucene.Net.Tests/Index/TestIndexableField.cs b/src/Lucene.Net.Tests/Index/TestIndexableField.cs
index 06b39ba..588c308 100644
--- a/src/Lucene.Net.Tests/Index/TestIndexableField.cs
+++ b/src/Lucene.Net.Tests/Index/TestIndexableField.cs
@@ -55,14 +55,14 @@ namespace Lucene.Net.Index
public MyField()
{
- fieldType = new IndexableFieldTypeAnonymousInnerClassHelper(this);
+ fieldType = new IndexableFieldTypeAnonymousClass(this);
}
- private class IndexableFieldTypeAnonymousInnerClassHelper : IIndexableFieldType
+ private class IndexableFieldTypeAnonymousClass : IIndexableFieldType
{
private MyField outerInstance;
- public IndexableFieldTypeAnonymousInnerClassHelper(MyField outerInstance)
+ public IndexableFieldTypeAnonymousClass(MyField outerInstance)
{
this.outerInstance = outerInstance;
}
@@ -261,7 +261,7 @@ namespace Lucene.Net.Index
int finalBaseCount = baseCount;
baseCount += fieldCount - 1;
- w.AddDocument(new IterableAnonymousInnerClassHelper(this, fieldCount, finalDocCount, finalBaseCount));
+ w.AddDocument(new IterableAnonymousClass(this, fieldCount, finalDocCount, finalBaseCount));
}
IndexReader r = w.GetReader();
@@ -379,7 +379,7 @@ namespace Lucene.Net.Index
dir.Dispose();
}
- private class IterableAnonymousInnerClassHelper : IEnumerable<IIndexableField>
+ private class IterableAnonymousClass : IEnumerable<IIndexableField>
{
private readonly TestIndexableField outerInstance;
@@ -387,7 +387,7 @@ namespace Lucene.Net.Index
private int finalDocCount;
private int finalBaseCount;
- public IterableAnonymousInnerClassHelper(TestIndexableField outerInstance, int fieldCount, int finalDocCount, int finalBaseCount)
+ public IterableAnonymousClass(TestIndexableField outerInstance, int fieldCount, int finalDocCount, int finalBaseCount)
{
this.outerInstance = outerInstance;
this.fieldCount = fieldCount;
@@ -397,7 +397,7 @@ namespace Lucene.Net.Index
public virtual IEnumerator<IIndexableField> GetEnumerator()
{
- return new IteratorAnonymousInnerClassHelper(this, outerInstance);
+ return new IteratorAnonymousClass(this, outerInstance);
}
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
@@ -405,12 +405,12 @@ namespace Lucene.Net.Index
return GetEnumerator();
}
- private class IteratorAnonymousInnerClassHelper : IEnumerator<IIndexableField>
+ private class IteratorAnonymousClass : IEnumerator<IIndexableField>
{
- private readonly IterableAnonymousInnerClassHelper outerInstance;
+ private readonly IterableAnonymousClass outerInstance;
private readonly TestIndexableField outerTextIndexableField;
- public IteratorAnonymousInnerClassHelper(IterableAnonymousInnerClassHelper outerInstance, TestIndexableField outerTextIndexableField)
+ public IteratorAnonymousClass(IterableAnonymousClass outerInstance, TestIndexableField outerTextIndexableField)
{
this.outerInstance = outerInstance;
this.outerTextIndexableField = outerTextIndexableField;
diff --git a/src/Lucene.Net.Tests/Index/TestMixedDocValuesUpdates.cs b/src/Lucene.Net.Tests/Index/TestMixedDocValuesUpdates.cs
index e6e5d59..61a7417 100644
--- a/src/Lucene.Net.Tests/Index/TestMixedDocValuesUpdates.cs
+++ b/src/Lucene.Net.Tests/Index/TestMixedDocValuesUpdates.cs
@@ -278,7 +278,7 @@ namespace Lucene.Net.Index
{
string f = "f" + i;
string cf = "cf" + i;
- threads[i] = new ThreadAnonymousInnerClassHelper(this, "UpdateThread-" + i, writer, numDocs, done, numUpdates, f, cf);
+ threads[i] = new ThreadAnonymousClass(this, "UpdateThread-" + i, writer, numDocs, done, numUpdates, f, cf);
}
foreach (ThreadJob t in threads)
@@ -323,7 +323,7 @@ namespace Lucene.Net.Index
dir.Dispose();
}
- private class ThreadAnonymousInnerClassHelper : ThreadJob
+ private class ThreadAnonymousClass : ThreadJob
{
private readonly TestMixedDocValuesUpdates outerInstance;
@@ -334,7 +334,7 @@ namespace Lucene.Net.Index
private readonly string f;
private readonly string cf;
- public ThreadAnonymousInnerClassHelper(TestMixedDocValuesUpdates outerInstance, string str, IndexWriter writer, int numDocs, CountdownEvent done, AtomicInt32 numUpdates, string f, string cf)
+ public ThreadAnonymousClass(TestMixedDocValuesUpdates outerInstance, string str, IndexWriter writer, int numDocs, CountdownEvent done, AtomicInt32 numUpdates, string f, string cf)
: base(str)
{
this.outerInstance = outerInstance;
diff --git a/src/Lucene.Net.Tests/Index/TestNeverDelete.cs b/src/Lucene.Net.Tests/Index/TestNeverDelete.cs
index 8842b34..41e4d41 100644
--- a/src/Lucene.Net.Tests/Index/TestNeverDelete.cs
+++ b/src/Lucene.Net.Tests/Index/TestNeverDelete.cs
@@ -64,7 +64,7 @@ namespace Lucene.Net.Index
long stopTime = Environment.TickCount + AtLeast(1000);
for (int x = 0; x < indexThreads.Length; x++)
{
- indexThreads[x] = new ThreadAnonymousInnerClassHelper(w, stopTime, NewStringField, NewTextField);
+ indexThreads[x] = new ThreadAnonymousClass(w, stopTime, NewStringField, NewTextField);
indexThreads[x].Name = "Thread " + x;
indexThreads[x].Start();
}
@@ -105,7 +105,7 @@ namespace Lucene.Net.Index
System.IO.Directory.Delete(tmpDir.FullName, true);
}
- private class ThreadAnonymousInnerClassHelper : ThreadJob
+ private class ThreadAnonymousClass : ThreadJob
{
private readonly Func<string, string, Field.Store, Field> newStringField;
private readonly Func<string, string, Field.Store, Field> newTextField;
@@ -123,7 +123,7 @@ namespace Lucene.Net.Index
/// Passed in because <see cref="LuceneTestCase.NewTextField(string, string, Field.Store)"/>
/// is no longer static
/// </param>
- public ThreadAnonymousInnerClassHelper(RandomIndexWriter w, long stopTime,
+ public ThreadAnonymousClass(RandomIndexWriter w, long stopTime,
Func<string, string, Field.Store, Field> newStringField, Func<string, string, Field.Store, Field> newTextField)
{
this.w = w;
diff --git a/src/Lucene.Net.Tests/Index/TestNumericDocValuesUpdates.cs b/src/Lucene.Net.Tests/Index/TestNumericDocValuesUpdates.cs
index 7c51371..afd0ffc 100644
--- a/src/Lucene.Net.Tests/Index/TestNumericDocValuesUpdates.cs
+++ b/src/Lucene.Net.Tests/Index/TestNumericDocValuesUpdates.cs
@@ -623,7 +623,7 @@ namespace Lucene.Net.Index
{
Directory dir = NewDirectory();
IndexWriterConfig conf = NewIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(Random));
- conf.SetCodec(new Lucene46CodecAnonymousInnerClassHelper(this));
+ conf.SetCodec(new Lucene46CodecAnonymousClass(this));
IndexWriter writer = new IndexWriter(dir, conf);
Document doc = new Document();
@@ -654,11 +654,11 @@ namespace Lucene.Net.Index
dir.Dispose();
}
- private class Lucene46CodecAnonymousInnerClassHelper : Lucene46Codec
+ private class Lucene46CodecAnonymousClass : Lucene46Codec
{
private readonly TestNumericDocValuesUpdates outerInstance;
- public Lucene46CodecAnonymousInnerClassHelper(TestNumericDocValuesUpdates outerInstance)
+ public Lucene46CodecAnonymousClass(TestNumericDocValuesUpdates outerInstance)
{
this.outerInstance = outerInstance;
}
@@ -1161,7 +1161,7 @@ namespace Lucene.Net.Index
{
string f = "f" + i;
string cf = "cf" + i;
- threads[i] = new ThreadAnonymousInnerClassHelper(this, "UpdateThread-" + i, writer, numDocs, done, numUpdates, f, cf);
+ threads[i] = new ThreadAnonymousClass(this, "UpdateThread-" + i, writer, numDocs, done, numUpdates, f, cf);
}
foreach (ThreadJob t in threads)
@@ -1200,7 +1200,7 @@ namespace Lucene.Net.Index
dir.Dispose();
}
- private class ThreadAnonymousInnerClassHelper : ThreadJob
+ private class ThreadAnonymousClass : ThreadJob
{
private readonly TestNumericDocValuesUpdates outerInstance;
@@ -1211,7 +1211,7 @@ namespace Lucene.Net.Index
private readonly string f;
private readonly string cf;
- public ThreadAnonymousInnerClassHelper(TestNumericDocValuesUpdates outerInstance, string str, IndexWriter writer, int numDocs, CountdownEvent done, AtomicInt32 numUpdates, string f, string cf)
+ public ThreadAnonymousClass(TestNumericDocValuesUpdates outerInstance, string str, IndexWriter writer, int numDocs, CountdownEvent done, AtomicInt32 numUpdates, string f, string cf)
: base(str)
{
this.outerInstance = outerInstance;
@@ -1374,7 +1374,7 @@ namespace Lucene.Net.Index
Directory dir = NewDirectory();
IndexWriterConfig conf = NewIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(Random));
conf.SetMergePolicy(NoMergePolicy.COMPOUND_FILES); // disable merges to simplify test assertions.
- conf.SetCodec(new Lucene46CodecAnonymousInnerClassHelper2(this));
+ conf.SetCodec(new Lucene46CodecAnonymousClass2(this));
IndexWriter writer = new IndexWriter(dir, (IndexWriterConfig)conf.Clone());
Document doc = new Document();
doc.Add(new StringField("id", "d0", Store.NO));
@@ -1384,7 +1384,7 @@ namespace Lucene.Net.Index
writer.Dispose();
// change format
- conf.SetCodec(new Lucene46CodecAnonymousInnerClassHelper3(this));
+ conf.SetCodec(new Lucene46CodecAnonymousClass3(this));
writer = new IndexWriter(dir, (IndexWriterConfig)conf.Clone());
doc = new Document();
doc.Add(new StringField("id", "d1", Store.NO));
@@ -1406,11 +1406,11 @@ namespace Lucene.Net.Index
dir.Dispose();
}
- private class Lucene46CodecAnonymousInnerClassHelper2 : Lucene46Codec
+ private class Lucene46CodecAnonymousClass2 : Lucene46Codec
{
private readonly TestNumericDocValuesUpdates outerInstance;
- public Lucene46CodecAnonymousInnerClassHelper2(TestNumericDocValuesUpdates outerInstance)
+ public Lucene46CodecAnonymousClass2(TestNumericDocValuesUpdates outerInstance)
{
this.outerInstance = outerInstance;
}
@@ -1421,11 +1421,11 @@ namespace Lucene.Net.Index
}
}
- private class Lucene46CodecAnonymousInnerClassHelper3 : Lucene46Codec
+ private class Lucene46CodecAnonymousClass3 : Lucene46Codec
{
private readonly TestNumericDocValuesUpdates outerInstance;
- public Lucene46CodecAnonymousInnerClassHelper3(TestNumericDocValuesUpdates outerInstance)
+ public Lucene46CodecAnonymousClass3(TestNumericDocValuesUpdates outerInstance)
{
this.outerInstance = outerInstance;
}
diff --git a/src/Lucene.Net.Tests/Index/TestOmitTf.cs b/src/Lucene.Net.Tests/Index/TestOmitTf.cs
index 791284e..2fb3e0e 100644
--- a/src/Lucene.Net.Tests/Index/TestOmitTf.cs
+++ b/src/Lucene.Net.Tests/Index/TestOmitTf.cs
@@ -374,34 +374,34 @@ namespace Lucene.Net.Index
} // else OK because positions are not indexed
}
- searcher.Search(q1, new CountingHitCollectorAnonymousInnerClassHelper(this));
+ searcher.Search(q1, new CountingHitCollectorAnonymousClass(this));
//System.out.println(CountingHitCollector.getCount());
- searcher.Search(q2, new CountingHitCollectorAnonymousInnerClassHelper2(this));
+ searcher.Search(q2, new CountingHitCollectorAnonymousClass2(this));
//System.out.println(CountingHitCollector.getCount());
- searcher.Search(q3, new CountingHitCollectorAnonymousInnerClassHelper3(this));
+ searcher.Search(q3, new CountingHitCollectorAnonymousClass3(this));
//System.out.println(CountingHitCollector.getCount());
- searcher.Search(q4, new CountingHitCollectorAnonymousInnerClassHelper4(this));
+ searcher.Search(q4, new CountingHitCollectorAnonymousClass4(this));
//System.out.println(CountingHitCollector.getCount());
BooleanQuery bq = new BooleanQuery();
bq.Add(q1, Occur.MUST);
bq.Add(q4, Occur.MUST);
- searcher.Search(bq, new CountingHitCollectorAnonymousInnerClassHelper5(this));
+ searcher.Search(bq, new CountingHitCollectorAnonymousClass5(this));
Assert.AreEqual(15, CountingHitCollector.Count);
reader.Dispose();
dir.Dispose();
}
- private class CountingHitCollectorAnonymousInnerClassHelper : CountingHitCollector
+ private class CountingHitCollectorAnonymousClass : CountingHitCollector
{
private readonly TestOmitTf outerInstance;
- public CountingHitCollectorAnonymousInnerClassHelper(TestOmitTf outerInstance)
+ public CountingHitCollectorAnonymousClass(TestOmitTf outerInstance)
{
this.outerInstance = outerInstance;
}
@@ -422,11 +422,11 @@ namespace Lucene.Net.Index
}
}
- private class CountingHitCollectorAnonymousInnerClassHelper2 : CountingHitCollector
+ private class CountingHitCollectorAnonymousClass2 : CountingHitCollector
{
private readonly TestOmitTf outerInstance;
- public CountingHitCollectorAnonymousInnerClassHelper2(TestOmitTf outerInstance)
+ public CountingHitCollectorAnonymousClass2(TestOmitTf outerInstance)
{
this.outerInstance = outerInstance;
}
@@ -447,11 +447,11 @@ namespace Lucene.Net.Index
}
}
- private class CountingHitCollectorAnonymousInnerClassHelper3 : CountingHitCollector
+ private class CountingHitCollectorAnonymousClass3 : CountingHitCollector
{
private readonly TestOmitTf outerInstance;
- public CountingHitCollectorAnonymousInnerClassHelper3(TestOmitTf outerInstance)
+ public CountingHitCollectorAnonymousClass3(TestOmitTf outerInstance)
{
this.outerInstance = outerInstance;
}
@@ -473,11 +473,11 @@ namespace Lucene.Net.Index
}
}
- private class CountingHitCollectorAnonymousInnerClassHelper4 : CountingHitCollector
+ private class CountingHitCollectorAnonymousClass4 : CountingHitCollector
{
private readonly TestOmitTf outerInstance;
- public CountingHitCollectorAnonymousInnerClassHelper4(TestOmitTf outerInstance)
+ public CountingHitCollectorAnonymousClass4(TestOmitTf outerInstance)
{
this.outerInstance = outerInstance;
}
@@ -499,11 +499,11 @@ namespace Lucene.Net.Index
}
}
- private class CountingHitCollectorAnonymousInnerClassHelper5 : CountingHitCollector
+ private class CountingHitCollectorAnonymousClass5 : CountingHitCollector
{
private readonly TestOmitTf outerInstance;
- public CountingHitCollectorAnonymousInnerClassHelper5(TestOmitTf outerInstance)
+ public CountingHitCollectorAnonymousClass5(TestOmitTf outerInstance)
{
this.outerInstance = outerInstance;
}
diff --git a/src/Lucene.Net.Tests/Index/TestParallelCompositeReader.cs b/src/Lucene.Net.Tests/Index/TestParallelCompositeReader.cs
index 83ae254..f11c545 100644
--- a/src/Lucene.Net.Tests/Index/TestParallelCompositeReader.cs
+++ b/src/Lucene.Net.Tests/Index/TestParallelCompositeReader.cs
@@ -160,7 +160,7 @@ namespace Lucene.Net.Index
foreach (AtomicReaderContext cxt in pr.Leaves)
{
- cxt.Reader.AddReaderClosedListener(new ReaderClosedListenerAnonymousInnerClassHelper(this, listenerClosedCount));
+ cxt.Reader.AddReaderClosedListener(new ReaderClosedListenerAnonymousClass(this, listenerClosedCount));
}
pr.Dispose();
ir1.Dispose();
@@ -168,13 +168,13 @@ namespace Lucene.Net.Index
dir1.Dispose();
}
- private class ReaderClosedListenerAnonymousInnerClassHelper : IReaderClosedListener
+ private class ReaderClosedListenerAnonymousClass : IReaderClosedListener
{
private readonly TestParallelCompositeReader outerInstance;
private readonly int[] listenerClosedCount;
- public ReaderClosedListenerAnonymousInnerClassHelper(TestParallelCompositeReader outerInstance, int[] listenerClosedCount)
+ public ReaderClosedListenerAnonymousClass(TestParallelCompositeReader outerInstance, int[] listenerClosedCount)
{
this.outerInstance = outerInstance;
this.listenerClosedCount = listenerClosedCount;
@@ -202,20 +202,20 @@ namespace Lucene.Net.Index
foreach (AtomicReaderContext cxt in pr.Leaves)
{
- cxt.Reader.AddReaderClosedListener(new ReaderClosedListenerAnonymousInnerClassHelper2(this, listenerClosedCount));
+ cxt.Reader.AddReaderClosedListener(new ReaderClosedListenerAnonymousClass2(this, listenerClosedCount));
}
pr.Dispose();
Assert.AreEqual(3, listenerClosedCount[0]);
dir1.Dispose();
}
- private class ReaderClosedListenerAnonymousInnerClassHelper2 : IReaderClosedListener
+ private class ReaderClosedListenerAnonymousClass2 : IReaderClosedListener
{
private readonly TestParallelCompositeReader outerInstance;
private readonly int[] listenerClosedCount;
- public ReaderClosedListenerAnonymousInnerClassHelper2(TestParallelCompositeReader outerInstance, int[] listenerClosedCount)
+ public ReaderClosedListenerAnonymousClass2(TestParallelCompositeReader outerInstance, int[] listenerClosedCount)
{
this.outerInstance = outerInstance;
this.listenerClosedCount = listenerClosedCount;
@@ -491,7 +491,7 @@ namespace Lucene.Net.Index
string s = pr.ToString();
- Assert.IsTrue(s.StartsWith("ParallelCompositeReader(ParallelCompositeReaderAnonymousInnerClassHelper(ParallelAtomicReader(", StringComparison.Ordinal), "toString incorrect: " + s);
+ Assert.IsTrue(s.StartsWith("ParallelCompositeReader(ParallelCompositeReaderAnonymousClass(ParallelAtomicReader(", StringComparison.Ordinal), "toString incorrect: " + s);
pr.Dispose();
dir1.Dispose();
diff --git a/src/Lucene.Net.Tests/Index/TestPayloads.cs b/src/Lucene.Net.Tests/Index/TestPayloads.cs
index bc21cd9..5e36a16 100644
--- a/src/Lucene.Net.Tests/Index/TestPayloads.cs
+++ b/src/Lucene.Net.Tests/Index/TestPayloads.cs
@@ -486,7 +486,7 @@ namespace Lucene.Net.Index
ThreadJob[] ingesters = new ThreadJob[numThreads];
for (int i = 0; i < numThreads; i++)
{
- ingesters[i] = new ThreadAnonymousInnerClassHelper(this, numDocs, pool, writer, field);
+ ingesters[i] = new ThreadAnonymousClass(this, numDocs, pool, writer, field);
ingesters[i].Start();
}
@@ -519,7 +519,7 @@ namespace Lucene.Net.Index
Assert.AreEqual(pool.Count, numThreads);
}
- private class ThreadAnonymousInnerClassHelper : ThreadJob
+ private class ThreadAnonymousClass : ThreadJob
{
private readonly TestPayloads outerInstance;
@@ -528,7 +528,7 @@ namespace Lucene.Net.Index
private readonly IndexWriter writer;
private readonly string field;
- public ThreadAnonymousInnerClassHelper(TestPayloads outerInstance, int numDocs, ByteArrayPool pool, IndexWriter writer, string field)
+ public ThreadAnonymousClass(TestPayloads outerInstance, int numDocs, ByteArrayPool pool, IndexWriter writer, string field)
{
this.outerInstance = outerInstance;
this.numDocs = numDocs;
diff --git a/src/Lucene.Net.Tests/Index/TestPersistentSnapshotDeletionPolicy.cs b/src/Lucene.Net.Tests/Index/TestPersistentSnapshotDeletionPolicy.cs
index 1808768..21ad338 100644
--- a/src/Lucene.Net.Tests/Index/TestPersistentSnapshotDeletionPolicy.cs
+++ b/src/Lucene.Net.Tests/Index/TestPersistentSnapshotDeletionPolicy.cs
@@ -126,7 +126,7 @@ namespace Lucene.Net.Index
public virtual void TestExceptionDuringSave()
{
MockDirectoryWrapper dir = NewMockDirectory();
- dir.FailOn(new FailureAnonymousInnerClassHelper(this, dir));
+ dir.FailOn(new FailureAnonymousClass(this, dir));
IndexWriter writer = new IndexWriter(dir, GetConfig(Random, new PersistentSnapshotDeletionPolicy(new KeepOnlyLastCommitDeletionPolicy(), dir, OpenMode.CREATE_OR_APPEND)));
writer.AddDocument(new Document());
writer.Commit();
@@ -153,13 +153,13 @@ namespace Lucene.Net.Index
dir.Dispose();
}
- private class FailureAnonymousInnerClassHelper : Failure
+ private class FailureAnonymousClass : Failure
{
private readonly TestPersistentSnapshotDeletionPolicy outerInstance;
private MockDirectoryWrapper dir;
- public FailureAnonymousInnerClassHelper(TestPersistentSnapshotDeletionPolicy outerInstance, MockDirectoryWrapper dir)
+ public FailureAnonymousClass(TestPersistentSnapshotDeletionPolicy outerInstance, MockDirectoryWrapper dir)
{
this.outerInstance = outerInstance;
this.dir = dir;
diff --git a/src/Lucene.Net.Tests/Index/TestSnapshotDeletionPolicy.cs b/src/Lucene.Net.Tests/Index/TestSnapshotDeletionPolicy.cs
index 32f2ab1..21f490a 100644
--- a/src/Lucene.Net.Tests/Index/TestSnapshotDeletionPolicy.cs
+++ b/src/Lucene.Net.Tests/Index/TestSnapshotDeletionPolicy.cs
@@ -145,7 +145,7 @@ namespace Lucene.Net.Index
dp = (SnapshotDeletionPolicy)writer.Config.IndexDeletionPolicy;
writer.Commit();
- ThreadJob t = new ThreadAnonymousInnerClassHelper(stopTime, writer, NewField);
+ ThreadJob t = new ThreadAnonymousClass(stopTime, writer, NewField);
t.Start();
@@ -176,7 +176,7 @@ namespace Lucene.Net.Index
TestIndexWriter.AssertNoUnreferencedFiles(dir, "some files were not deleted but should have been");
}
- private class ThreadAnonymousInnerClassHelper : ThreadJob
+ private class ThreadAnonymousClass : ThreadJob
{
private readonly long stopTime;
private readonly IndexWriter writer;
@@ -187,7 +187,7 @@ namespace Lucene.Net.Index
/// Passed in because <see cref="LuceneTestCase.NewField(string, string, FieldType)"/>
/// is no longer static.
/// </param>
- public ThreadAnonymousInnerClassHelper(long stopTime, IndexWriter writer, Func<string, string, FieldType, Field> newFieldFunc)
+ public ThreadAnonymousClass(long stopTime, IndexWriter writer, Func<string, string, FieldType, Field> newFieldFunc)
{
this.stopTime = stopTime;
this.writer = writer;
@@ -360,7 +360,7 @@ namespace Lucene.Net.Index
for (int i = 0; i < threads.Length; i++)
{
int finalI = i;
- threads[i] = new ThreadAnonymousInnerClassHelper2(this, writer, sdp, snapshots, finalI);
+ threads[i] = new ThreadAnonymousClass2(this, writer, sdp, snapshots, finalI);
threads[i].Name = "t" + i;
}
@@ -388,7 +388,7 @@ namespace Lucene.Net.Index
dir.Dispose();
}
- private class ThreadAnonymousInnerClassHelper2 : ThreadJob
+ private class ThreadAnonymousClass2 : ThreadJob
{
private readonly TestSnapshotDeletionPolicy outerInstance;
@@ -397,7 +397,7 @@ namespace Lucene.Net.Index
private readonly IndexCommit[] snapshots;
private readonly int finalI;
- public ThreadAnonymousInnerClassHelper2(TestSnapshotDeletionPolicy outerInstance, IndexWriter writer, SnapshotDeletionPolicy sdp, IndexCommit[] snapshots, int finalI)
+ public ThreadAnonymousClass2(TestSnapshotDeletionPolicy outerInstance, IndexWriter writer, SnapshotDeletionPolicy sdp, IndexCommit[] snapshots, int finalI)
{
this.outerInstance = outerInstance;
this.writer = writer;
diff --git a/src/Lucene.Net.Tests/Index/TestStressNRT.cs b/src/Lucene.Net.Tests/Index/TestStressNRT.cs
index b552cdb..6590b7b 100644
--- a/src/Lucene.Net.Tests/Index/TestStressNRT.cs
+++ b/src/Lucene.Net.Tests/Index/TestStressNRT.cs
@@ -122,14 +122,14 @@ namespace Lucene.Net.Index
for (int i = 0; i < nWriteThreads; i++)
{
- ThreadJob thread = new ThreadAnonymousInnerClassHelper(this, "WRITER" + i, commitPercent, softCommitPercent, deletePercent, deleteByQueryPercent, ndocs, maxConcurrentCommits, tombstones, operations, storedOnlyType, numCommitting, writer);
+ ThreadJob thread = new ThreadAnonymousClass(this, "WRITER" + i, commitPercent, softCommitPercent, deletePercent, deleteByQueryPercent, ndocs, maxConcurrentCommits, tombstones, operations, storedOnlyType, numCommitting, writer);
threads.Add(thread);
}
for (int i = 0; i < nReadThreads; i++)
{
- ThreadJob thread = new ThreadAnonymousInnerClassHelper2(this, "READER" + i, ndocs, tombstones, operations);
+ ThreadJob thread = new ThreadAnonymousClass2(this, "READER" + i, ndocs, tombstones, operations);
threads.Add(thread);
}
@@ -153,7 +153,7 @@ namespace Lucene.Net.Index
dir.Dispose();
}
- private class ThreadAnonymousInnerClassHelper : ThreadJob
+ private class ThreadAnonymousClass : ThreadJob
{
private readonly TestStressNRT outerInstance;
@@ -169,7 +169,7 @@ namespace Lucene.Net.Index
private readonly AtomicInt32 numCommitting;
private readonly RandomIndexWriter writer;
- public ThreadAnonymousInnerClassHelper(TestStressNRT outerInstance, string str, int commitPercent, int softCommitPercent, int deletePercent, int deleteByQueryPercent, int ndocs, int maxConcurrentCommits, bool tombstones, AtomicInt64 operations, FieldType storedOnlyType, AtomicInt32 numCommitting, RandomIndexWriter writer)
+ public ThreadAnonymousClass(TestStressNRT outerInstance, string str, int commitPercent, int softCommitPercent, int deletePercent, int deleteByQueryPercent, int ndocs, int maxConcurrentCommits, bool tombstones, AtomicInt64 operations, FieldType storedOnlyType, AtomicInt32 numCommitting, RandomIndexWriter writer)
: base(str)
{
this.outerInstance = outerInstance;
@@ -406,7 +406,7 @@ namespace Lucene.Net.Index
}
}
- private class ThreadAnonymousInnerClassHelper2 : ThreadJob
+ private class ThreadAnonymousClass2 : ThreadJob
{
private readonly TestStressNRT outerInstance;
@@ -414,7 +414,7 @@ namespace Lucene.Net.Index
private readonly bool tombstones;
private readonly AtomicInt64 operations;
- public ThreadAnonymousInnerClassHelper2(TestStressNRT outerInstance, string str, int ndocs, bool tombstones, AtomicInt64 operations)
+ public ThreadAnonymousClass2(TestStressNRT outerInstance, string str, int ndocs, bool tombstones, AtomicInt64 operations)
: base(str)
{
this.outerInstance = outerInstance;
diff --git a/src/Lucene.Net.Tests/Index/TestTermdocPerf.cs b/src/Lucene.Net.Tests/Index/TestTermdocPerf.cs
index 0701821..3401e81 100644
--- a/src/Lucene.Net.Tests/Index/TestTermdocPerf.cs
+++ b/src/Lucene.Net.Tests/Index/TestTermdocPerf.cs
@@ -86,7 +86,7 @@ namespace Lucene.Net.Index
{
internal virtual void AddDocs(Random random, Directory dir, int ndocs, string field, string val, int maxTF, float percentDocs)
{
- Analyzer analyzer = new AnalyzerAnonymousInnerClassHelper(random, val, maxTF, percentDocs);
+ Analyzer analyzer = new AnalyzerAnonymousClass(random, val, maxTF, percentDocs);
Document doc = new Document();
@@ -102,14 +102,14 @@ namespace Lucene.Net.Index
writer.Dispose();
}
- private class AnalyzerAnonymousInnerClassHelper : Analyzer
+ private class AnalyzerAnonymousClass : Analyzer
{
private readonly Random random;
private readonly string val;
private readonly int maxTf;
private readonly float percentDocs;
- public AnalyzerAnonymousInnerClassHelper(Random random, string val, int maxTF, float percentDocs)
+ public AnalyzerAnonymousClass(Random random, string val, int maxTF, float percentDocs)
{
this.random = random;
this.val = val;
diff --git a/src/Lucene.Net.Tests/Index/TestThreadedForceMerge.cs b/src/Lucene.Net.Tests/Index/TestThreadedForceMerge.cs
index ba2d8d2..78b93d3 100644
--- a/src/Lucene.Net.Tests/Index/TestThreadedForceMerge.cs
+++ b/src/Lucene.Net.Tests/Index/TestThreadedForceMerge.cs
@@ -90,7 +90,7 @@ namespace Lucene.Net.Index
{
int iFinal = i;
IndexWriter writerFinal = writer;
- threads[i] = new ThreadAnonymousInnerClassHelper(this, iterFinal, customType, iFinal, writerFinal);
+ threads[i] = new ThreadAnonymousClass(this, iterFinal, customType, iFinal, writerFinal);
}
for (int i = 0; i < NUM_THREADS; i++)
@@ -121,7 +121,7 @@ namespace Lucene.Net.Index
writer.Dispose();
}
- private class ThreadAnonymousInnerClassHelper : ThreadJob
+ private class ThreadAnonymousClass : ThreadJob
{
private readonly TestThreadedForceMerge outerInstance;
@@ -130,7 +130,7 @@ namespace Lucene.Net.Index
private readonly int iFinal;
private readonly IndexWriter writerFinal;
- public ThreadAnonymousInnerClassHelper(TestThreadedForceMerge outerInstance, int iterFinal, FieldType customType, int iFinal, IndexWriter writerFinal)
+ public ThreadAnonymousClass(TestThreadedForceMerge outerInstance, int iterFinal, FieldType customType, int iFinal, IndexWriter writerFinal)
{
this.outerInstance = outerInstance;
this.iterFinal = iterFinal;
diff --git a/src/Lucene.Net.Tests/Search/Payloads/TestPayloadExplanations.cs b/src/Lucene.Net.Tests/Search/Payloads/TestPayloadExplanations.cs
index b8f2605..08a6f8c 100644
--- a/src/Lucene.Net.Tests/Search/Payloads/TestPayloadExplanations.cs
+++ b/src/Lucene.Net.Tests/Search/Payloads/TestPayloadExplanations.cs
@@ -41,14 +41,14 @@ namespace Lucene.Net.Search.Payloads
public override void SetUp()
{
base.SetUp();
- searcher.Similarity = new DefaultSimilarityAnonymousInnerClassHelper(this);
+ searcher.Similarity = new DefaultSimilarityAnonymousClass(this);
}
- private class DefaultSimilarityAnonymousInnerClassHelper : DefaultSimilarity
+ private class DefaultSimilarityAnonymousClass : DefaultSimilarity
{
private readonly TestPayloadExplanations outerInstance;
- public DefaultSimilarityAnonymousInnerClassHelper(TestPayloadExplanations outerInstance)
+ public DefaultSimilarityAnonymousClass(TestPayloadExplanations outerInstance)
{
this.outerInstance = outerInstance;
}
diff --git a/src/Lucene.Net.Tests/Search/Spans/TestFieldMaskingSpanQuery.cs b/src/Lucene.Net.Tests/Search/Spans/TestFieldMaskingSpanQuery.cs
index 16301e7..7b37049 100644
--- a/src/Lucene.Net.Tests/Search/Spans/TestFieldMaskingSpanQuery.cs
+++ b/src/Lucene.Net.Tests/Search/Spans/TestFieldMaskingSpanQuery.cs
@@ -120,7 +120,7 @@ namespace Lucene.Net.Search.Spans
public virtual void TestRewrite1()
{
// mask an anon SpanQuery class that rewrites to something else.
- SpanQuery q = new FieldMaskingSpanQuery(new SpanTermQueryAnonymousInnerClassHelper(this, new Term("last", "sally")), "first");
+ SpanQuery q = new FieldMaskingSpanQuery(new SpanTermQueryAnonymousClass(this, new Term("last", "sally")), "first");
SpanQuery qr = (SpanQuery)searcher.Rewrite(q);
@@ -131,11 +131,11 @@ namespace Lucene.Net.Search.Spans
Assert.AreEqual(2, terms.Count);
}
- private class SpanTermQueryAnonymousInnerClassHelper : SpanTermQuery
+ private class SpanTermQueryAnonymousClass : SpanTermQuery
{
private readonly TestFieldMaskingSpanQuery outerInstance;
- public SpanTermQueryAnonymousInnerClassHelper(TestFieldMaskingSpanQuery outerInstance, Term term)
+ public SpanTermQueryAnonymousClass(TestFieldMaskingSpanQuery outerInstance, Term term)
: base(term)
{
this.outerInstance = outerInstance;
diff --git a/src/Lucene.Net.Tests/Search/Spans/TestSpans.cs b/src/Lucene.Net.Tests/Search/Spans/TestSpans.cs
index c83a054..7beb2c2 100644
--- a/src/Lucene.Net.Tests/Search/Spans/TestSpans.cs
+++ b/src/Lucene.Net.Tests/Search/Spans/TestSpans.cs
@@ -417,7 +417,7 @@ namespace Lucene.Net.Search.Spans
{
AtomicReaderContext ctx = leaves[i];
- Similarity sim = new DefaultSimilarityAnonymousInnerClassHelper(this);
+ Similarity sim = new DefaultSimilarityAnonymousClass(this);
Similarity oldSim = searcher.Similarity;
Scorer spanScorer;
@@ -446,11 +446,11 @@ namespace Lucene.Net.Search.Spans
}
}
- private class DefaultSimilarityAnonymousInnerClassHelper : DefaultSimilarity
+ private class DefaultSimilarityAnonymousClass : DefaultSimilarity
{
private readonly TestSpans outerInstance;
- public DefaultSimilarityAnonymousInnerClassHelper(TestSpans outerInstance)
+ public DefaultSimilarityAnonymousClass(TestSpans outerInstance)
{
this.outerInstance = outerInstance;
}
diff --git a/src/Lucene.Net.Tests/Search/TestAutomatonQuery.cs b/src/Lucene.Net.Tests/Search/TestAutomatonQuery.cs
index e3fc408..b7197cc 100644
--- a/src/Lucene.Net.Tests/Search/TestAutomatonQuery.cs
+++ b/src/Lucene.Net.Tests/Search/TestAutomatonQuery.cs
@@ -239,7 +239,7 @@ namespace Lucene.Net.Search
ThreadJob[] threads = new ThreadJob[numThreads];
for (int threadID = 0; threadID < numThreads; threadID++)
{
- ThreadJob thread = new ThreadAnonymousInnerClassHelper(this, queries, startingGun);
+ ThreadJob thread = new ThreadAnonymousClass(this, queries, startingGun);
threads[threadID] = thread;
thread.Start();
}
@@ -250,14 +250,14 @@ namespace Lucene.Net.Search
}
}
- private class ThreadAnonymousInnerClassHelper : ThreadJob
+ private class ThreadAnonymousClass : ThreadJob
{
private readonly TestAutomatonQuery outerInstance;
private readonly AutomatonQuery[] queries;
private readonly CountdownEvent startingGun;
- public ThreadAnonymousInnerClassHelper(TestAutomatonQuery outerInstance, AutomatonQuery[] queries, CountdownEvent startingGun)
+ public ThreadAnonymousClass(TestAutomatonQuery outerInstance, AutomatonQuery[] queries, CountdownEvent startingGun)
{
this.outerInstance = outerInstance;
this.queries = queries;
diff --git a/src/Lucene.Net.Tests/Search/TestBoolean2.cs b/src/Lucene.Net.Tests/Search/TestBoolean2.cs
index 73dd5c6..1700852 100644
--- a/src/Lucene.Net.Tests/Search/TestBoolean2.cs
+++ b/src/Lucene.Net.Tests/Search/TestBoolean2.cs
@@ -268,7 +268,7 @@ namespace Lucene.Net.Search
Similarity oldSimilarity = searcher.Similarity;
try
{
- searcher.Similarity = new DefaultSimilarityAnonymousInnerClassHelper(this);
+ searcher.Similarity = new DefaultSimilarityAnonymousClass(this);
QueriesTest(query, expDocNrs);
}
finally
@@ -277,11 +277,11 @@ namespace Lucene.Net.Search
}
}
- private class DefaultSimilarityAnonymousInnerClassHelper : DefaultSimilarity
+ private class DefaultSimilarityAnonymousClass : DefaultSimilarity
{
private readonly TestBoolean2 outerInstance;
- public DefaultSimilarityAnonymousInnerClassHelper(TestBoolean2 outerInstance)
+ public DefaultSimilarityAnonymousClass(TestBoolean2 outerInstance)
{
this.outerInstance = outerInstance;
}
diff --git a/src/Lucene.Net.Tests/Search/TestBooleanMinShouldMatch.cs b/src/Lucene.Net.Tests/Search/TestBooleanMinShouldMatch.cs
index c84036f..5a0746c 100644
--- a/src/Lucene.Net.Tests/Search/TestBooleanMinShouldMatch.cs
+++ b/src/Lucene.Net.Tests/Search/TestBooleanMinShouldMatch.cs
@@ -345,7 +345,7 @@ namespace Lucene.Net.Search
int maxLev = 4;
// callback object to set a random setMinimumNumberShouldMatch
- TestBoolean2.ICallback minNrCB = new CallbackAnonymousInnerClassHelper(this, field, vals);
+ TestBoolean2.ICallback minNrCB = new CallbackAnonymousClass(this, field, vals);
// increase number of iterations for more complete testing
int num = AtLeast(20);
@@ -383,14 +383,14 @@ namespace Lucene.Net.Search
// System.out.println("Total hits:"+tot);
}
- private class CallbackAnonymousInnerClassHelper : TestBoolean2.ICallback
+ private class CallbackAnonymousClass : TestBoolean2.ICallback
{
private readonly TestBooleanMinShouldMatch outerInstance;
private readonly string field;
private readonly string[] vals;
- public CallbackAnonymousInnerClassHelper(TestBooleanMinShouldMatch outerInstance, string field, string[] vals)
+ public CallbackAnonymousClass(TestBooleanMinShouldMatch outerInstance, string field, string[] vals)
{
this.outerInstance = outerInstance;
this.field = field;
@@ -458,7 +458,7 @@ namespace Lucene.Net.Search
Similarity oldSimilarity = s.Similarity;
try
{
- s.Similarity = new DefaultSimilarityAnonymousInnerClassHelper(this);
+ s.Similarity = new DefaultSimilarityAnonymousClass(this);
BooleanQuery q1 = new BooleanQuery();
q1.Add(new TermQuery(new Term("data", "1")), Occur.SHOULD);
BooleanQuery q2 = new BooleanQuery();
@@ -474,11 +474,11 @@ namespace Lucene.Net.Search
}
}
- private class DefaultSimilarityAnonymousInnerClassHelper : DefaultSimilarity
+ private class DefaultSimilarityAnonymousClass : DefaultSimilarity
{
private readonly TestBooleanMinShouldMatch outerInstance;
- public DefaultSimilarityAnonymousInnerClassHelper(TestBooleanMinShouldMatch outerInstance)
+ public DefaultSimilarityAnonymousClass(TestBooleanMinShouldMatch outerInstance)
{
this.outerInstance = outerInstance;
}
@@ -495,7 +495,7 @@ namespace Lucene.Net.Search
Similarity oldSimilarity = s.Similarity;
try
{
- s.Similarity = new DefaultSimilarityAnonymousInnerClassHelper2(this);
+ s.Similarity = new DefaultSimilarityAnonymousClass2(this);
BooleanQuery q1 = new BooleanQuery();
q1.Add(new TermQuery(new Term("data", "1")), Occur.SHOULD);
BooleanQuery q2 = new BooleanQuery();
@@ -511,11 +511,11 @@ namespace Lucene.Net.Search
}
}
- private class DefaultSimilarityAnonymousInnerClassHelper2 : DefaultSimilarity
+ private class DefaultSimilarityAnonymousClass2 : DefaultSimilarity
{
private readonly TestBooleanMinShouldMatch outerInstance;
- public DefaultSimilarityAnonymousInnerClassHelper2(TestBooleanMinShouldMatch outerInstance)
+ public DefaultSimilarityAnonymousClass2(TestBooleanMinShouldMatch outerInstance)
{
this.outerInstance = outerInstance;
}
diff --git a/src/Lucene.Net.Tests/Search/TestBooleanOr.cs b/src/Lucene.Net.Tests/Search/TestBooleanOr.cs
index 278cbf1..999caef 100644
--- a/src/Lucene.Net.Tests/Search/TestBooleanOr.cs
+++ b/src/Lucene.Net.Tests/Search/TestBooleanOr.cs
@@ -208,7 +208,7 @@ namespace Lucene.Net.Search
FixedBitSet hits = new FixedBitSet(docCount);
AtomicInt32 end = new AtomicInt32();
- ICollector c = new CollectorAnonymousInnerClassHelper(this, scorer, hits, end);
+ ICollector c = new CollectorAnonymousClass(this, scorer, hits, end);
while (end < docCount)
{
@@ -222,7 +222,7 @@ namespace Lucene.Net.Search
dir.Dispose();
}
- private class CollectorAnonymousInnerClassHelper : ICollector
+ private class CollectorAnonymousClass : ICollector
{
private readonly TestBooleanOr outerInstance;
@@ -230,7 +230,7 @@ namespace Lucene.Net.Search
private readonly FixedBitSet hits;
private readonly AtomicInt32 end;
- public CollectorAnonymousInnerClassHelper(TestBooleanOr outerInstance, BulkScorer scorer, FixedBitSet hits, AtomicInt32 end)
+ public CollectorAnonymousClass(TestBooleanOr outerInstance, BulkScorer scorer, FixedBitSet hits, AtomicInt32 end)
{
this.outerInstance = outerInstance;
this.scorer = scorer;
diff --git a/src/Lucene.Net.Tests/Search/TestBooleanQuery.cs b/src/Lucene.Net.Tests/Search/TestBooleanQuery.cs
index c1868f0..752fd42 100644
--- a/src/Lucene.Net.Tests/Search/TestBooleanQuery.cs
+++ b/src/Lucene.Net.Tests/Search/TestBooleanQuery.cs
@@ -403,7 +403,7 @@ namespace Lucene.Net.Search
w.AddDocument(doc);
IndexReader r = w.GetReader();
w.Dispose();
- IndexSearcher s = new IndexSearcherAnonymousInnerClassHelper(this, r);
+ IndexSearcher s = new IndexSearcherAnonymousClass(this, r);
BooleanQuery bq = new BooleanQuery();
bq.Add(new TermQuery(new Term("field", "some")), Occur.SHOULD);
bq.Add(new TermQuery(new Term("field", "text")), Occur.SHOULD);
@@ -414,11 +414,11 @@ namespace Lucene.Net.Search
dir.Dispose();
}
- private class IndexSearcherAnonymousInnerClassHelper : IndexSearcher
+ private class IndexSearcherAnonymousClass : IndexSearcher
{
private readonly TestBooleanQuery outerInstance;
- public IndexSearcherAnonymousInnerClassHelper(TestBooleanQuery outerInstance, IndexReader r)
+ public IndexSearcherAnonymousClass(TestBooleanQuery outerInstance, IndexReader r)
: base(r)
{
this.outerInstance = outerInstance;
diff --git a/src/Lucene.Net.Tests/Search/TestBooleanScorer.cs b/src/Lucene.Net.Tests/Search/TestBooleanScorer.cs
index a257e2b..c39e321 100644
--- a/src/Lucene.Net.Tests/Search/TestBooleanScorer.cs
+++ b/src/Lucene.Net.Tests/Search/TestBooleanScorer.cs
@@ -99,13 +99,13 @@ namespace Lucene.Net.Search
BooleanWeight weight = (BooleanWeight)(new BooleanQuery()).CreateWeight(searcher);
BulkScorer[] scorers = new BulkScorer[] {
- new BulkScorerAnonymousInnerClassHelper()
+ new BulkScorerAnonymousClass()
};
BooleanScorer bs = new BooleanScorer(weight, false, 1, scorers, Collections.EmptyList<BulkScorer>(), scorers.Length);
IList<int> hits = new List<int>();
- bs.Score(new CollectorAnonymousInnerClassHelper(this, hits));
+ bs.Score(new CollectorAnonymousClass(this, hits));
Assert.AreEqual(1, hits.Count, "should have only 1 hit");
Assert.AreEqual(3000, (int)hits[0], "hit should have been docID=3000");
@@ -113,7 +113,7 @@ namespace Lucene.Net.Search
directory.Dispose();
}
- private class BulkScorerAnonymousInnerClassHelper : BulkScorer
+ private class BulkScorerAnonymousClass : BulkScorer
{
private int doc = -1;
@@ -130,13 +130,13 @@ namespace Lucene.Net.Search
}
}
- private class CollectorAnonymousInnerClassHelper : ICollector
+ private class CollectorAnonymousClass : ICollector
{
private readonly TestBooleanScorer outerInstance;
private readonly IList<int> hits;
- public CollectorAnonymousInnerClassHelper(TestBooleanScorer outerInstance, IList<int> hits)
+ public CollectorAnonymousClass(TestBooleanScorer outerInstance, IList<int> hits)
{
this.outerInstance = outerInstance;
this.hits = hits;
@@ -189,7 +189,7 @@ namespace Lucene.Net.Search
q.Add(new BooleanClause(new TermQuery(new Term("field", "33")), Occur.SHOULD));
int[] count = new int[1];
- s.Search(q, new CollectorAnonymousInnerClassHelper2(this, doc, count));
+ s.Search(q, new CollectorAnonymousClass2(this, doc, count));
Assert.AreEqual(1, count[0]);
@@ -197,14 +197,14 @@ namespace Lucene.Net.Search
d.Dispose();
}
- private class CollectorAnonymousInnerClassHelper2 : ICollector
+ private class CollectorAnonymousClass2 : ICollector
{
private readonly TestBooleanScorer outerInstance;
private Document doc;
private readonly int[] count;
- public CollectorAnonymousInnerClassHelper2(TestBooleanScorer outerInstance, Document doc, int[] count)
+ public CollectorAnonymousClass2(TestBooleanScorer outerInstance, Document doc, int[] count)
{
this.outerInstance = outerInstance;
this.doc = doc;
@@ -241,14 +241,14 @@ namespace Lucene.Net.Search
public override Weight CreateWeight(IndexSearcher searcher)
{
- return new WeightAnonymousInnerClassHelper(this);
+ return new WeightAnonymousClass(this);
}
- private class WeightAnonymousInnerClassHelper : Weight
+ private class WeightAnonymousClass : Weight
{
private readonly CrazyMustUseBulkScorerQuery outerInstance;
- public WeightAnonymousInnerClassHelper(CrazyMustUseBulkScorerQuery outerInstance)
+ public WeightAnonymousClass(CrazyMustUseBulkScorerQuery outerInstance)
{
this.outerInstance = outerInstance;
}
@@ -276,14 +276,14 @@ namespace Lucene.Net.Search
public override BulkScorer GetBulkScorer(AtomicReaderContext context, bool scoreDocsInOrder, IBits acceptDocs)
{
- return new BulkScorerAnonymousInnerClassHelper(this);
+ return new BulkScorerAnonymousClass(this);
}
- private class BulkScorerAnonymousInnerClassHelper : BulkScorer
+ private class BulkScorerAnonymousClass : BulkScorer
{
- private readonly WeightAnonymousInnerClassHelper outerInstance;
+ private readonly WeightAnonymousClass outerInstance;
- public BulkScorerAnonymousInnerClassHelper(WeightAnonymousInnerClassHelper outerInstance)
+ public BulkScorerAnonymousClass(WeightAnonymousClass outerInstance)
{
this.outerInstance = outerInstance;
}
diff --git a/src/Lucene.Net.Tests/Search/TestCachingCollector.cs b/src/Lucene.Net.Tests/Search/TestCachingCollector.cs
index ef26cf7..b347636 100644
--- a/src/Lucene.Net.Tests/Search/TestCachingCollector.cs
+++ b/src/Lucene.Net.Tests/Search/TestCachingCollector.cs
@@ -100,15 +100,15 @@ namespace Lucene.Net.Search
}
// now replay them
- cc.Replay(new CollectorAnonymousInnerClassHelper(this));
+ cc.Replay(new CollectorAnonymousClass(this));
}
}
- private class CollectorAnonymousInnerClassHelper : ICollector
+ private class CollectorAnonymousClass : ICollector
{
private readonly TestCachingCollector outerInstance;
- public CollectorAnonymousInnerClassHelper(TestCachingCollector outerInstance)
+ public CollectorAnonymousClass(TestCachingCollector outerInstance)
{
this.outerInstance = outerInstance;
prevDocID = -1;
diff --git a/src/Lucene.Net.Tests/Search/TestCachingWrapperFilter.cs b/src/Lucene.Net.Tests/Search/TestCachingWrapperFilter.cs
index fe3375a..12e98eb 100644
--- a/src/Lucene.Net.Tests/Search/TestCachingWrapperFilter.cs
+++ b/src/Lucene.Net.Tests/Search/TestCachingWrapperFilter.cs
@@ -219,7 +219,7 @@ namespace Lucene.Net.Search
IndexReader reader = SlowCompositeReaderWrapper.Wrap(DirectoryReader.Open(dir));
AtomicReaderContext context = (AtomicReaderContext)reader.Context;
- Filter filter = new FilterAnonymousInnerClassHelper(this, context);
+ Filter filter = new FilterAnonymousClass(this, context);
CachingWrapperFilter cacher = new CachingWrapperFilter(filter);
// the caching filter should return the empty set constant
@@ -230,13 +230,13 @@ namespace Lucene.Net.Search
dir.Dispose();
}
- private class FilterAnonymousInnerClassHelper : Filter
+ private class FilterAnonymousClass : Filter
{
private readonly TestCachingWrapperFilter outerInstance;
private AtomicReaderContext context;
- public FilterAnonymousInnerClassHelper(TestCachingWrapperFilter outerInstance, AtomicReaderContext context)
+ public FilterAnonymousClass(TestCachingWrapperFilter outerInstance, AtomicReaderContext context)
{
this.outerInstance = outerInstance;
this.context = context;
@@ -262,7 +262,7 @@ namespace Lucene.Net.Search
IndexReader reader = SlowCompositeReaderWrapper.Wrap(DirectoryReader.Open(dir));
AtomicReaderContext context = (AtomicReaderContext)reader.Context;
- Filter filter = new FilterAnonymousInnerClassHelper2(this, context);
+ Filter filter = new FilterAnonymousClass2(this, context);
CachingWrapperFilter cacher = new CachingWrapperFilter(filter);
// the caching filter should return the empty set constant
@@ -272,13 +272,13 @@ namespace Lucene.Net.Search
dir.Dispose();
}
- private class FilterAnonymousInnerClassHelper2 : Filter
+ private class FilterAnonymousClass2 : Filter
{
private readonly TestCachingWrapperFilter outerInstance;
private AtomicReaderContext context;
- public FilterAnonymousInnerClassHelper2(TestCachingWrapperFilter outerInstance, AtomicReaderContext context)
+ public FilterAnonymousClass2(TestCachingWrapperFilter outerInstance, AtomicReaderContext context)
{
this.outerInstance = outerInstance;
this.context = context;
@@ -286,14 +286,14 @@ namespace Lucene.Net.Search
public override DocIdSet GetDocIdSet(AtomicReaderContext context, IBits acceptDocs)
{
- return new DocIdSetAnonymousInnerClassHelper(this);
+ return new DocIdSetAnonymousClass(this);
}
- private class DocIdSetAnonymousInnerClassHelper : DocIdSet
+ private class DocIdSetAnonymousClass : DocIdSet
{
- private readonly FilterAnonymousInnerClassHelper2 outerInstance;
+ private readonly FilterAnonymousClass2 outerInstance;
- public DocIdSetAnonymousInnerClassHelper(FilterAnonymousInnerClassHelper2 outerInstance)
+ public DocIdSetAnonymousClass(FilterAnonymousClass2 outerInstance)
{
this.outerInstance = outerInstance;
}
@@ -357,17 +357,17 @@ namespace Lucene.Net.Search
// is cacheable:
AssertDocIdSetCacheable(reader, FieldCacheRangeFilter.NewInt32Range("test", Convert.ToInt32(10), Convert.ToInt32(20), true, true), true);
// a fixedbitset filter is always cacheable
- AssertDocIdSetCacheable(reader, new FilterAnonymousInnerClassHelper3(this), true);
+ AssertDocIdSetCacheable(reader, new FilterAnonymousClass3(this), true);
reader.Dispose();
dir.Dispose();
}
- private class FilterAnonymousInnerClassHelper3 : Filter
+ private class FilterAnonymousClass3 : Filter
{
private readonly TestCachingWrapperFilter outerInstance;
- public FilterAnonymousInnerClassHelper3(TestCachingWrapperFilter outerInstance)
+ public FilterAnonymousClass3(TestCachingWrapperFilter outerInstance)
{
this.outerInstance = outerInstance;
}
diff --git a/src/Lucene.Net.Tests/Search/TestComplexExplanations.cs b/src/Lucene.Net.Tests/Search/TestComplexExplanations.cs
index 382aba8..a85f8f1 100644
--- a/src/Lucene.Net.Tests/Search/TestComplexExplanations.cs
+++ b/src/Lucene.Net.Tests/Search/TestComplexExplanations.cs
@@ -52,12 +52,12 @@ namespace Lucene.Net.Search
// must be static for weight serialization tests
private static DefaultSimilarity CreateQnorm1Similarity()
{
- return new DefaultSimilarityAnonymousInnerClassHelper();
+ return new DefaultSimilarityAnonymousClass();
}
- private class DefaultSimilarityAnonymousInnerClassHelper : DefaultSimilarity
+ private class DefaultSimilarityAnonymousClass : DefaultSimilarity
{
- public DefaultSimilarityAnonymousInnerClassHelper()
+ public DefaultSimilarityAnonymousClass()
{
}
diff --git a/src/Lucene.Net.Tests/Search/TestConjunctions.cs b/src/Lucene.Net.Tests/Search/TestConjunctions.cs
index 75656be..a8ccb89 100644
--- a/src/Lucene.Net.Tests/Search/TestConjunctions.cs
+++ b/src/Lucene.Net.Tests/Search/TestConjunctions.cs
@@ -105,14 +105,14 @@ namespace Lucene.Net.Search
public override SimWeight ComputeWeight(float queryBoost, CollectionStatistics collectionStats, params TermStatistics[] termStats)
{
- return new SimWeightAnonymousInnerClassHelper(this);
+ return new SimWeightAnonymousClass(this);
}
- private class SimWeightAnonymousInnerClassHelper : SimWeight
+ private class SimWeightAnonymousClass : SimWeight
{
private readonly TFSimilarity outerInstance;
- public SimWeightAnonymousInnerClassHelper(TFSimilarity outerInstance)
+ public SimWeightAnonymousClass(TFSimilarity outerInstance)
{
this.outerInstance = outerInstance;
}
@@ -130,14 +130,14 @@ namespace Lucene.Net.Search
public override SimScorer GetSimScorer(SimWeight weight, AtomicReaderContext context)
{
- return new SimScorerAnonymousInnerClassHelper(this);
+ return new SimScorerAnonymousClass(this);
}
- private class SimScorerAnonymousInnerClassHelper : SimScorer
+ private class SimScorerAnonymousClass : SimScorer
{
private readonly TFSimilarity outerInstance;
- public SimScorerAnonymousInnerClassHelper(TFSimilarity outerInstance)
+ public SimScorerAnonymousClass(TFSimilarity outerInstance)
{
this.outerInstance = outerInstance;
}
diff --git a/src/Lucene.Net.Tests/Search/TestConstantScoreQuery.cs b/src/Lucene.Net.Tests/Search/TestConstantScoreQuery.cs
index 80747c3..4a4cde6 100644
--- a/src/Lucene.Net.Tests/Search/TestConstantScoreQuery.cs
+++ b/src/Lucene.Net.Tests/Search/TestConstantScoreQuery.cs
@@ -59,11 +59,11 @@ namespace Lucene.Net.Search
private void CheckHits(IndexSearcher searcher, Query q, float expectedScore, string scorerClassName, string innerScorerClassName)
{
int[] count = new int[1];
- searcher.Search(q, new CollectorAnonymousInnerClassHelper(this, expectedScore, scorerClassName, innerScorerClassName, count));
+ searcher.Search(q, new CollectorAnonymousClass(this, expectedScore, scorerClassName, innerScorerClassName, count));
Assert.AreEqual(1, count[0], "invalid number of results");
}
- private class CollectorAnonymousInnerClassHelper : ICollector
+ private class CollectorAnonymousClass : ICollector
{
private readonly TestConstantScoreQuery outerInstance;
@@ -72,7 +72,7 @@ namespace Lucene.Net.Search
private readonly string innerScorerClassName;
private readonly int[] count;
- public CollectorAnonymousInnerClassHelper(TestConstantScoreQuery outerInstance, float expectedScore, string scorerClassName, string innerScorerClassName, int[] count)
+ public CollectorAnonymousClass(TestConstantScoreQuery outerInstance, float expectedScore, string scorerClassName, string innerScorerClassName, int[] count)
{
this.outerInstance = outerInstance;
this.expectedScore = expectedScore;
@@ -132,7 +132,7 @@ namespace Lucene.Net.Search
searcher = NewSearcher(reader, true, false);
// set a similarity that does not normalize our boost away
- searcher.Similarity = new DefaultSimilarityAnonymousInnerClassHelper(this);
+ searcher.Similarity = new DefaultSimilarityAnonymousClass(this);
Query csq1 = new ConstantScoreQuery(new TermQuery(new Term("field", "term")));
csq1.Boost = 2.0f;
@@ -167,11 +167,11 @@ namespace Lucene.Net.Search
}
}
- private class DefaultSimilarityAnonymousInnerClassHelper : DefaultSimilarity
+ private class DefaultSimilarityAnonymousClass : DefaultSimilarity
{
private readonly TestConstantScoreQuery outerInstance;
- public DefaultSimilarityAnonymousInnerClassHelper(TestConstantScoreQuery outerInstance)
+ public DefaultSimilarityAnonymousClass(TestConstantScoreQuery outerInstance)
{
this.outerInstance = outerInstance;
}
diff --git a/src/Lucene.Net.Tests/Search/TestControlledRealTimeReopenThread.cs b/src/Lucene.Net.Tests/Search/TestControlledRealTimeReopenThread.cs
index 7f35c2b..62244cf 100644
--- a/src/Lucene.Net.Tests/Search/TestControlledRealTimeReopenThread.cs
+++ b/src/Lucene.Net.Tests/Search/TestControlledRealTimeReopenThread.cs
@@ -274,7 +274,7 @@ namespace Lucene.Net.Search
genWriter = new TrackingIndexWriter(m_writer);
- SearcherFactory sf = new SearcherFactoryAnonymousInnerClassHelper(this, es);
+ SearcherFactory sf = new SearcherFactoryAnonymousClass(this, es);
nrtNoDeletes = new SearcherManager(m_writer, false, sf);
nrtDeletes = new SearcherManager(m_writer, true, sf);
@@ -296,13 +296,13 @@ namespace Lucene.Net.Search
nrtNoDeletesThread.Start();
}
- private class SearcherFactoryAnonymousInnerClassHelper : SearcherFactory
+ private class SearcherFactoryAnonymousClass : SearcherFactory
{
private readonly TestControlledRealTimeReopenThread outerInstance;
private TaskScheduler es;
- public SearcherFactoryAnonymousInnerClassHelper(TestControlledRealTimeReopenThread outerInstance, TaskScheduler es)
+ public SearcherFactoryAnonymousClass(TestControlledRealTimeReopenThread outerInstance, TaskScheduler es)
{
this.outerInstance = outerInstance;
this.es = es;
@@ -399,7 +399,7 @@ namespace Lucene.Net.Search
doc.Add(NewTextField("test", "test", Field.Store.YES));
writer.AddDocument(doc);
manager.MaybeRefresh();
- var t = new ThreadAnonymousInnerClassHelper(this, latch, signal, writer, manager);
+ var t = new ThreadAnonymousClass(this, latch, signal, writer, manager);
t.Start();
_writer.waitAfterUpdate = true; // wait in addDocument to let some reopens go through
long lastGen = writer.UpdateDocument(new Term("foo", "bar"), doc); // once this returns the doc is already reflected in the last reopen
@@ -423,7 +423,7 @@ namespace Lucene.Net.Search
}
AtomicBoolean finished = new AtomicBoolean(false);
- var waiter = new ThreadAnonymousInnerClassHelper2(this, lastGen, thread, finished);
+ var waiter = new ThreadAnonymousClass2(this, lastGen, thread, finished);
waiter.Start();
manager.MaybeRefresh();
waiter.Join(1000);
@@ -437,7 +437,7 @@ namespace Lucene.Net.Search
IOUtils.Dispose(manager, _writer, d);
}
- private class ThreadAnonymousInnerClassHelper : ThreadJob
+ private class ThreadAnonymousClass : ThreadJob
{
private readonly TestControlledRealTimeReopenThread outerInstance;
@@ -446,7 +446,7 @@ namespace Lucene.Net.Search
private readonly TrackingIndexWriter writer;
private readonly SearcherManager manager;
- public ThreadAnonymousInnerClassHelper(TestControlledRealTimeReopenThread outerInstance, CountdownEvent latch, CountdownEvent signal, TrackingIndexWriter writer, SearcherManager manager)
+ public ThreadAnonymousClass(TestControlledRealTimeReopenThread outerInstance, CountdownEvent latch, CountdownEvent signal, TrackingIndexWriter writer, SearcherManager manager)
{
this.outerInstance = outerInstance;
this.latch = latch;
@@ -476,7 +476,7 @@ namespace Lucene.Net.Search
}
}
- private class ThreadAnonymousInnerClassHelper2 : ThreadJob
+ private class ThreadAnonymousClass2 : ThreadJob
{
private readonly TestControlledRealTimeReopenThread outerInstance;
@@ -484,7 +484,7 @@ namespace Lucene.Net.Search
private readonly ControlledRealTimeReopenThread<IndexSearcher> thread;
private readonly AtomicBoolean finished;
- public ThreadAnonymousInnerClassHelper2(TestControlledRealTimeReopenThread outerInstance, long lastGen, ControlledRealTimeReopenThread<IndexSearcher> thread, AtomicBoolean finished)
+ public ThreadAnonymousClass2(TestControlledRealTimeReopenThread outerInstance, long lastGen, ControlledRealTimeReopenThread<IndexSearcher> thread, AtomicBoolean finished)
{
this.outerInstance = outerInstance;
this.lastGen = lastGen;
@@ -561,7 +561,7 @@ namespace Lucene.Net.Search
IndexReader other = DirectoryReader.Open(dir);
- SearcherFactory theEvilOne = new SearcherFactoryAnonymousInnerClassHelper2(this, other);
+ SearcherFactory theEvilOne = new SearcherFactoryAnonymousClass2(this, other);
try
{
@@ -579,13 +579,13 @@ namespace Lucene.Net.Search
dir.Dispose();
}
- private class SearcherFactoryAnonymousInnerClassHelper2 : SearcherFactory
+ private class SearcherFactoryAnonymousClass2 : SearcherFactory
{
private readonly TestControlledRealTimeReopenThread outerInstance;
private readonly IndexReader other;
- public SearcherFactoryAnonymousInnerClassHelper2(TestControlledRealTimeReopenThread outerInstance, IndexReader other)
+ public SearcherFactoryAnonymousClass2(TestControlledRealTimeReopenThread outerInstance, IndexReader other)
{
this.outerInstance = outerInstance;
this.other = other;
@@ -608,7 +608,7 @@ namespace Lucene.Net.Search
IndexWriter iw = new IndexWriter(dir, new IndexWriterConfig(TEST_VERSION_CURRENT, null));
AtomicBoolean afterRefreshCalled = new AtomicBoolean(false);
SearcherManager sm = new SearcherManager(iw, true, new SearcherFactory());
- sm.AddListener(new RefreshListenerAnonymousInnerClassHelper(this, afterRefreshCalled));
+ sm.AddListener(new RefreshListenerAnonymousClass(this, afterRefreshCalled));
iw.AddDocument(new Document());
iw.Commit();
assertFalse(afterRefreshCalled);
@@ -619,13 +619,13 @@ namespace Lucene.Net.Search
dir.Dispose();
}
- private class RefreshListenerAnonymousInnerClassHelper : ReferenceManager.IRefreshListener
+ private class RefreshListenerAnonymousClass : ReferenceManager.IRefreshListener
{
private readonly TestControlledRealTimeReopenThread outerInstance;
private AtomicBoolean afterRefreshCalled;
- public RefreshListenerAnonymousInnerClassHelper(TestControlledRealTimeReopenThread outerInstance, AtomicBoolean afterRefreshCalled)
+ public RefreshListenerAnonymousClass(TestControlledRealTimeReopenThread outerInstance, AtomicBoolean afterRefreshCalled)
{
this.outerInstance = outerInstance;
this.afterRefreshCalled = afterRefreshCalled;
@@ -686,7 +686,7 @@ namespace Lucene.Net.Search
{
if (i > 0 && i % 50 == 0)
{
- ThreadJob commitThread = new RunnableAnonymousInnerClassHelper(this, sdp, dir, iw);
+ ThreadJob commitThread = new RunnableAnonymousClass(this, sdp, dir, iw);
commitThread.Start();
commitThreads.Add(commitThread);
}
@@ -715,7 +715,7 @@ namespace Lucene.Net.Search
dir.Dispose();
}
- private class RunnableAnonymousInnerClassHelper : ThreadJob
+ private class RunnableAnonymousClass : ThreadJob
{
private readonly TestControlledRealTimeReopenThread outerInstance;
@@ -723,7 +723,7 @@ namespace Lucene.Net.Search
private Directory dir;
private IndexWriter iw;
- public RunnableAnonymousInnerClassHelper(TestControlledRealTimeReopenThread outerInstance, SnapshotDeletionPolicy sdp, Directory dir, IndexWriter iw)
+ public RunnableAnonymousClass(TestControlledRealTimeReopenThread outerInstance, SnapshotDeletionPolicy sdp, Directory dir, IndexWriter iw)
{
this.outerInstance = outerInstance;
this.sdp = sdp;
diff --git a/src/Lucene.Net.Tests/Search/TestDocBoost.cs b/src/Lucene.Net.Tests/Search/TestDocBoost.cs
index 89de72d..7d7f719 100644
--- a/src/Lucene.Net.Tests/Search/TestDocBoost.cs
+++ b/src/Lucene.Net.Tests/Search/TestDocBoost.cs
@@ -64,7 +64,7 @@ namespace Lucene.Net.Search
float[] scores = new float[4];
IndexSearcher searcher = NewSearcher(reader);
- searcher.Search(new TermQuery(new Term("field", "word")), new CollectorAnonymousInnerClassHelper(this, scores));
+ searcher.Search(new TermQuery(new Term("field", "word")), new CollectorAnonymousClass(this, scores));
float lastScore = 0.0f;
@@ -82,13 +82,13 @@ namespace Lucene.Net.Search
store.Dispose();
}
- private class CollectorAnonymousInnerClassHelper : ICollector
+ private class CollectorAnonymousClass : ICollector
{
private readonly TestDocBoost outerInstance;
private readonly float[] scores;
- public CollectorAnonymousInnerClassHelper(TestDocBoost outerInstance, float[] scores)
+ public CollectorAnonymousClass(TestDocBoost outerInstance, float[] scores)
{
this.outerInstance = outerInstance;
this.scores = scores;
diff --git a/src/Lucene.Net.Tests/Search/TestDocIdSet.cs b/src/Lucene.Net.Tests/Search/TestDocIdSet.cs
index e04dbe3..ff795c3 100644
--- a/src/Lucene.Net.Tests/Search/TestDocIdSet.cs
+++ b/src/Lucene.Net.Tests/Search/TestDocIdSet.cs
@@ -41,9 +41,9 @@ namespace Lucene.Net.Search
public virtual void TestFilteredDocIdSet()
{
const int maxdoc = 10;
- DocIdSet innerSet = new DocIdSetAnonymousInnerClassHelper(this, maxdoc);
+ DocIdSet innerSet = new DocIdSetAnonymousClass(this, maxdoc);
- DocIdSet filteredSet = new FilteredDocIdSetAnonymousInnerClassHelper(this, innerSet);
+ DocIdSet filteredSet = new FilteredDocIdSetAnonymousClass(this, innerSet);
DocIdSetIterator iter = filteredSet.GetIterator();
List<int?> list = new List<int?>();
@@ -74,13 +74,13 @@ namespace Lucene.Net.Search
}
}
- private class DocIdSetAnonymousInnerClassHelper : DocIdSet
+ private class DocIdSetAnonymousClass : DocIdSet
{
private readonly TestDocIdSet outerInstance;
private readonly int maxdoc;
- public DocIdSetAnonymousInnerClassHelper(TestDocIdSet outerInstance, int maxdoc)
+ public DocIdSetAnonymousClass(TestDocIdSet outerInstance, int maxdoc)
{
this.outerInstance = outerInstance;
this.maxdoc = maxdoc;
@@ -88,14 +88,14 @@ namespace Lucene.Net.Search
public override DocIdSetIterator GetIterator()
{
- return new DocIdSetIteratorAnonymousInnerClassHelper(this);
+ return new DocIdSetIteratorAnonymousClass(this);
}
- private class DocIdSetIteratorAnonymousInnerClassHelper : DocIdSetIterator
+ private class DocIdSetIteratorAnonymousClass : DocIdSetIterator
{
- private readonly DocIdSetAnonymousInnerClassHelper outerInstance;
+ private readonly DocIdSetAnonymousClass outerInstance;
- public DocIdSetIteratorAnonymousInnerClassHelper(DocIdSetAnonymousInnerClassHelper outerInstance)
+ public DocIdSetIteratorAnonymousClass(DocIdSetAnonymousClass outerInstance)
{
this.outerInstance = outerInstance;
docid = -1;
@@ -123,11 +123,11 @@ namespace Lucene.Net.Search
}
}
- private class FilteredDocIdSetAnonymousInnerClassHelper : FilteredDocIdSet
+ private class FilteredDocIdSetAnonymousClass : FilteredDocIdSet
{
private readonly TestDocIdSet outerInstance;
- public FilteredDocIdSetAnonymousInnerClassHelper(TestDocIdSet outerInstance, DocIdSet innerSet)
+ public FilteredDocIdSetAnonymousClass(TestDocIdSet outerInstance, DocIdSet innerSet)
: base(innerSet)
{
this.outerInstance = outerInstance;
@@ -161,18 +161,18 @@ namespace Lucene.Net.Search
Assert.AreEqual(1, searcher.Search(new MatchAllDocsQuery(), 10).TotalHits);
// Now search w/ a Filter which returns a null DocIdSet
- Filter f = new FilterAnonymousInnerClassHelper(this);
+ Filter f = new FilterAnonymousClass(this);
Assert.AreEqual(0, searcher.Search(new MatchAllDocsQuery(), f, 10).TotalHits);
reader.Dispose();
dir.Dispose();
}
- private class FilterAnonymousInnerClassHelper : Filter
+ private class FilterAnonymousClass : Filter
{
private readonly TestDocIdSet outerInstance;
- public FilterAnonymousInnerClassHelper(TestDocIdSet outerInstance)
+ public FilterAnonymousClass(TestDocIdSet outerInstance)
{
this.outerInstance = outerInstance;
}
@@ -203,33 +203,33 @@ namespace Lucene.Net.Search
Assert.AreEqual(1, searcher.Search(new MatchAllDocsQuery(), 10).TotalHits);
// Now search w/ a Filter which returns a null DocIdSet
- Filter f = new FilterAnonymousInnerClassHelper2(this);
+ Filter f = new FilterAnonymousClass2(this);
Assert.AreEqual(0, searcher.Search(new MatchAllDocsQuery(), f, 10).TotalHits);
reader.Dispose();
dir.Dispose();
}
- private class FilterAnonymousInnerClassHelper2 : Filter
+ private class FilterAnonymousClass2 : Filter
{
private readonly TestDocIdSet outerInstance;
- public FilterAnonymousInnerClassHelper2(TestDocIdSet outerInstance)
+ public FilterAnonymousClass2(TestDocIdSet outerInstance)
{
this.outerInstance = outerInstance;
}
public override DocIdSet GetDocIdSet(AtomicReaderContext context, IBits acceptDocs)
{
- DocIdSet innerNullIteratorSet = new DocIdSetAnonymousInnerClassHelper2(this);
- return new FilteredDocIdSetAnonymousInnerClassHelper2(this, innerNullIteratorSet);
+ DocIdSet innerNullIteratorSet = new DocIdSetAnonymousClass2(this);
+ return new FilteredDocIdSetAnonymousClass2(this, innerNullIteratorSet);
}
- private class DocIdSetAnonymousInnerClassHelper2 : DocIdSet
+ private class DocIdSetAnonymousClass2 : DocIdSet
{
- private readonly FilterAnonymousInnerClassHelper2 outerInstance;
+ private readonly FilterAnonymousClass2 outerInstance;
- public DocIdSetAnonymousInnerClassHelper2(FilterAnonymousInnerClassHelper2 outerInstance)
+ public DocIdSetAnonymousClass2(FilterAnonymousClass2 outerInstance)
{
this.outerInstance = outerInstance;
}
@@ -240,11 +240,11 @@ namespace Lucene.Net.Search
}
}
- private class FilteredDocIdSetAnonymousInnerClassHelper2 : FilteredDocIdSet
+ private class FilteredDocIdSetAnonymousClass2 : FilteredDocIdSet
{
- private readonly FilterAnonymousInnerClassHelper2 outerInstance;
+ private readonly FilterAnonymousClass2 outerInstance;
- public FilteredDocIdSetAnonymousInnerClassHelper2(FilterAnonymousInnerClassHelper2 outerInstance, DocIdSet innerNullIteratorSet)
+ public FilteredDocIdSetAnonymousClass2(FilterAnonymousClass2 outerInstance, DocIdSet innerNullIteratorSet)
: base(innerNullIteratorSet)
{
this.outerInstance = outerInstance;
diff --git a/src/Lucene.Net.Tests/Search/TestDocValuesScoring.cs b/src/Lucene.Net.Tests/Search/TestDocValuesScoring.cs
index f28a299..91491c8 100644
--- a/src/Lucene.Net.Tests/Search/TestDocValuesScoring.cs
+++ b/src/Lucene.Net.Tests/Search/TestDocValuesScoring.cs
@@ -89,7 +89,7 @@ namespace Lucene.Net.Search
this,
#endif
ir, false);
- searcher2.Similarity = new PerFieldSimilarityWrapperAnonymousInnerClassHelper(this, field, @base);
+ searcher2.Similarity = new PerFieldSimilarityWrapperAnonymousClass(this, field, @base);
// in this case, we searched on field "foo". first document should have 2x the score.
TermQuery tq = new TermQuery(new Term("foo", "quick"));
@@ -157,14 +157,14 @@ namespace Lucene.Net.Search
dir.Dispose();
}
- private class PerFieldSimilarityWrapperAnonymousInnerClassHelper : PerFieldSimilarityWrapper
+ private class PerFieldSimilarityWrapperAnonymousClass : PerFieldSimilarityWrapper
{
private readonly TestDocValuesScoring outerInstance;
private Field field;
private Similarity @base;
- public PerFieldSimilarityWrapperAnonymousInnerClassHelper(TestDocValuesScoring outerInstance, Field field, Similarity @base)
+ public PerFieldSimilarityWrapperAnonymousClass(TestDocValuesScoring outerInstance, Field field, Similarity @base)
{
this.outerInstance = outerInstance;
this.field = field;
@@ -222,17 +222,17 @@ namespace Lucene.Net.Search
SimScorer sub = sim.GetSimScorer(stats, context);
FieldCache.Singles values = FieldCache.DEFAULT.GetSingles(context.AtomicReader, boostField, false);
- return new SimScorerAnonymousInnerClassHelper(this, sub, values);
+ return new SimScorerAnonymousClass(this, sub, values);
}
- private class SimScorerAnonymousInnerClassHelper : SimScorer
+ private class SimScorerAnonymousClass : SimScorer
{
private readonly BoostingSimilarity outerInstance;
private readonly SimScorer sub;
private readonly FieldCache.Singles values;
- public SimScorerAnonymousInnerClassHelper(BoostingSimilarity outerInstance, SimScorer sub, FieldCache.Singles values)
+ public SimScorerAnonymousClass(BoostingSimilarity outerInstance, SimScorer sub, FieldCache.Singles values)
{
this.outerInstance = outerInstance;
this.sub = sub;
diff --git a/src/Lucene.Net.Tests/Search/TestEarlyTermination.cs b/src/Lucene.Net.Tests/Search/TestEarlyTermination.cs
index 8b43018..431f29b 100644
--- a/src/Lucene.Net.Tests/Search/TestEarlyTermination.cs
+++ b/src/Lucene.Net.Tests/Search/TestEarlyTermination.cs
@@ -71,18 +71,18 @@ namespace Lucene.Net.Search
for (int i = 0; i < iters; ++i)
{
IndexSearcher searcher = NewSearcher(reader);
- ICollector collector = new CollectorAnonymousInnerClassHelper(this);
+ ICollector collector = new CollectorAnonymousClass(this);
searcher.Search(new MatchAllDocsQuery(), collector);
}
reader.Dispose();
}
- private class CollectorAnonymousInnerClassHelper : ICollector
+ private class CollectorAnonymousClass : ICollector
{
private readonly TestEarlyTermination outerInstance;
- public CollectorAnonymousInnerClassHelper(TestEarlyTermination outerInstance)
+ public CollectorAnonymousClass(TestEarlyTermination outerInstance)
{
this.outerInstance = outerInstance;
outOfOrder = Random.NextBoolean();
diff --git a/src/Lucene.Net.Tests/Search/TestElevationComparator.cs b/src/Lucene.Net.Tests/Search/TestElevationComparator.cs
index 7bb7e7a..848fa97 100644
--- a/src/Lucene.Net.Tests/Search/TestElevationComparator.cs
+++ b/src/Lucene.Net.Tests/Search/TestElevationComparator.cs
@@ -147,17 +147,17 @@ namespace Lucene.Net.Search
public override FieldComparer NewComparer(string fieldname, int numHits, int sortPos, bool reversed)
{
- return new FieldComparerAnonymousInnerClassHelper(this, fieldname, numHits);
+ return new FieldComparerAnonymousClass(this, fieldname, numHits);
}
- private class FieldComparerAnonymousInnerClassHelper : FieldComparer
+ private class FieldComparerAnonymousClass : FieldComparer
{
private readonly ElevationComparerSource outerInstance;
private readonly string fieldname;
private int numHits;
- public FieldComparerAnonymousInnerClassHelper(ElevationComparerSource outerInstance, string fieldname, int numHits)
+ public FieldComparerAnonymousClass(ElevationComparerSource outerInstance, string fieldname, int numHits)
{
this.outerInstance = outerInstance;
this.fieldname = fieldname;
diff --git a/src/Lucene.Net.Tests/Search/TestFieldCache.cs b/src/Lucene.Net.Tests/Search/TestFieldCache.cs
index f892f25..30086c0 100644
--- a/src/Lucene.Net.Tests/Search/TestFieldCache.cs
+++ b/src/Lucene.Net.Tests/Search/TestFieldCache.cs
@@ -487,10 +487,10 @@ namespace Lucene.Net.Search
AtomicBoolean failed = new AtomicBoolean();
AtomicInt32 iters = new AtomicInt32();
int NUM_ITER = 200 * RandomMultiplier;
- Barrier restart = new Barrier(NUM_THREADS, (barrier) => new RunnableAnonymousInnerClassHelper(this, cache, iters).Run());
+ Barrier restart = new Barrier(NUM_THREADS, (barrier) => new RunnableAnonymousClass(this, cache, iters).Run());
for (int threadIDX = 0; threadIDX < NUM_THREADS; threadIDX++)
{
- threads[threadIDX] = new ThreadAnonymousInnerClassHelper(this, cache, failed, iters, NUM_ITER, restart);
+ threads[threadIDX] = new ThreadAnonymousClass(this, cache, failed, iters, NUM_ITER, restart);
threads[threadIDX].Start();
}
@@ -501,14 +501,14 @@ namespace Lucene.Net.Search
Assert.IsFalse(failed);
}
- private class RunnableAnonymousInnerClassHelper //: IThreadRunnable
+ private class RunnableAnonymousClass //: IThreadRunnable
{
private readonly TestFieldCache outerInstance;
private readonly IFieldCache cache;
private readonly AtomicInt32 iters;
- public RunnableAnonymousInnerClassHelper(TestFieldCache outerInstance, IFieldCache cache, AtomicInt32 iters)
+ public RunnableAnonymousClass(TestFieldCache outerInstance, IFieldCache cache, AtomicInt32 iters)
{
this.outerInstance = outerInstance;
this.cache = cache;
@@ -522,7 +522,7 @@ namespace Lucene.Net.Search
}
}
- private class ThreadAnonymousInnerClassHelper : ThreadJob
+ private class ThreadAnonymousClass : ThreadJob
{
private readonly TestFieldCache outerInstance;
@@ -532,7 +532,7 @@ namespace Lucene.Net.Search
private readonly int NUM_ITER;
private readonly Barrier restart;
- public ThreadAnonymousInnerClassHelper(TestFieldCache outerInstance, IFieldCache cache, AtomicBoolean failed, AtomicInt32 iters, int NUM_ITER, Barrier restart)
+ public ThreadAnonymousClass(TestFieldCache outerInstance, IFieldCache cache, AtomicBoolean failed, AtomicInt32 iters, int NUM_ITER, Barrier restart)
{
this.outerInstance = outerInstance;
this.cache = cache;
diff --git a/src/Lucene.Net.Tests/Search/TestFilteredQuery.cs b/src/Lucene.Net.Tests/Search/TestFilteredQuery.cs
index 575b8bc..416733f 100644
--- a/src/Lucene.Net.Tests/Search/TestFilteredQuery.cs
+++ b/src/Lucene.Net.Tests/Search/TestFilteredQuery.cs
@@ -103,12 +103,12 @@ namespace Lucene.Net.Search
// must be static for serialization tests
private static Filter NewStaticFilterB()
{
- return new FilterAnonymousInnerClassHelper();
+ return new FilterAnonymousClass();
}
- private class FilterAnonymousInnerClassHelper : Filter
+ private class FilterAnonymousClass : Filter
{
- public FilterAnonymousInnerClassHelper()
+ public FilterAnonymousClass()
{
}
@@ -226,12 +226,12 @@ namespace Lucene.Net.Search
// must be static for serialization tests
private static Filter NewStaticFilterA()
{
- return new FilterAnonymousInnerClassHelper2();
+ return new FilterAnonymousClass2();
}
- private class FilterAnonymousInnerClassHelper2 : Filter
+ private class FilterAnonymousClass2 : Filter
{
- public FilterAnonymousInnerClassHelper2()
+ public FilterAnonymousClass2()
{
}
@@ -500,14 +500,14 @@ namespace Lucene.Net.Search
{
if (useRandomAccess)
{
- return new RandomAccessFilterStrategyAnonymousInnerClassHelper();
+ return new RandomAccessFilterStrategyAnonymousClass();
}
return TestUtil.RandomFilterStrategy(random);
}
- private class RandomAccessFilterStrategyAnonymousInnerClassHelper : FilteredQuery.RandomAccessFilterStrategy
+ private class RandomAccessFilterStrategyAnonymousClass : FilteredQuery.RandomAccessFilterStrategy
{
- public RandomAccessFilterStrategyAnonymousInnerClassHelper()
+ public RandomAccessFilterStrategyAnonymousClass()
{
}
@@ -544,20 +544,20 @@ namespace Lucene.Net.Search
writer.Dispose();
IndexSearcher searcher = NewSearcher(reader);
- Query query = new FilteredQuery(new TermQuery(new Term("field", "0")), new FilterAnonymousInnerClassHelper3(this, reader), FilteredQuery.QUERY_FIRST_FILTER_STRATEGY);
+ Query query = new FilteredQuery(new TermQuery(new Term("field", "0")), new FilterAnonymousClass3(this, reader), FilteredQuery.QUERY_FIRST_FILTER_STRATEGY);
TopDocs search = searcher.Search(query, 10);
Assert.AreEqual(totalDocsWithZero, search.TotalHits);
IOUtils.Dispose(reader, writer, directory);
}
- private class FilterAnonymousInnerClassHelper3 : Filter
+ private class FilterAnonymousClass3 : Filter
{
private readonly TestFilteredQuery outerInstance;
private IndexReader reader;
- public FilterAnonymousInnerClassHelper3(TestFilteredQuery outerInstance, IndexReader reader)
+ public FilterAnonymousClass3(TestFilteredQuery outerInstance, IndexReader reader)
{
this.outerInstance = outerInstance;
this.reader = reader;
@@ -578,18 +578,18 @@ namespace Lucene.Net.Search
{
bitSet.Set(d);
}
- return new DocIdSetAnonymousInnerClassHelper(this, nullBitset, reader, bitSet);
+ return new DocIdSetAnonymousClass(this, nullBitset, reader, bitSet);
}
- private class DocIdSetAnonymousInnerClassHelper : DocIdSet
+ private class DocIdSetAnonymousClass : DocIdSet
{
- private readonly FilterAnonymousInnerClassHelper3 outerInstance;
+ private readonly FilterAnonymousClass3 outerInstance;
private readonly bool nullBitset;
private readonly AtomicReader reader;
private readonly BitSet bitSet;
- public DocIdSetAnonymousInnerClassHelper(FilterAnonymousInnerClassHelper3 outerInstance, bool nullBitset, AtomicReader reader, BitSet bitSet)
+ public DocIdSetAnonymousClass(FilterAnonymousClass3 outerInstance, bool nullBitset, AtomicReader reader, BitSet bitSet)
{
this.outerInstance = outerInstance;
this.nullBitset = nullBitset;
@@ -605,15 +605,15 @@ namespace Lucene.Net.Search
{
return null;
}
- return new BitsAnonymousInnerClassHelper(this);
+ return new BitsAnonymousClass(this);
}
}
- private class BitsAnonymousInnerClassHelper : IBits
+ private class BitsAnonymousClass : IBits
{
- private readonly DocIdSetAnonymousInnerClassHelper outerInstance;
+ private readonly DocIdSetAnonymousClass outerInstance;
- public BitsAnonymousInnerClassHelper(DocIdSetAnonymousInnerClassHelper outerInstance)
+ public BitsAnonymousClass(DocIdSetAnonymousClass outerInstance)
{
this.outerInstance = outerInstance;
}
@@ -662,7 +662,7 @@ namespace Lucene.Net.Search
writer.Dispose();
bool queryFirst = Random.NextBoolean();
IndexSearcher searcher = NewSearcher(reader);
- Query query = new FilteredQuery(new TermQuery(new Term("field", "0")), new FilterAnonymousInnerClassHelper4(this, queryFirst), queryFirst ? FilteredQuery.LEAP_FROG_QUERY_FIRST_STRATEGY : Random
+ Query query = new FilteredQuery(new TermQuery(new Term("field", "0")), new FilterAnonymousClass4(this, queryFirst), queryFirst ? FilteredQuery.LEAP_FROG_QUERY_FIRST_STRATEGY : Random
.NextBoolean() ? FilteredQuery.RANDOM_ACCESS_FILTER_STRATEGY : FilteredQuery.LEAP_FROG_FILTER_FIRST_STRATEGY); // if filterFirst, we can use random here since bits are null
TopDocs search = searcher.Search(query, 10);
@@ -670,13 +670,13 @@ namespace Lucene.Net.Search
IOUtils.Dispose(reader, writer, directory);
}
- private class FilterAnonymousInnerClassHelper4 : Filter
+ private class FilterAnonymousClass4 : Filter
{
private readonly TestFilteredQuery outerInstance;
private readonly bool queryFirst;
- public FilterAnonymousInnerClassHelper4(TestFilteredQuery outerInstance, bool queryFirst)
+ public FilterAnonymousClass4(TestFilteredQuery outerInstance, bool queryFirst)
{
this.outerInstance = outerInstance;
this.queryFirst = queryFirst;
@@ -684,16 +684,16 @@ namespace Lucene.Net.Search
public override DocIdSet GetDocIdSet(AtomicReaderContext context, IBits acceptDocs)
{
- return new DocIdSetAnonymousInnerClassHelper2(this, context);
+ return new DocIdSetAnonymousClass2(this, context);
}
- private class DocIdSetAnonymousInnerClassHelper2 : DocIdSet
+ private class DocIdSetAnonymousClass2 : DocIdSet
{
- private readonly FilterAnonymousInnerClassHelper4 outerInstance;
+ private readonly FilterAnonymousClass4 outerInstance;
... 4744 lines suppressed ...