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 d90db0284f10775a0098bc2928fdf7decda2cdbb Author: Michael <[email protected]> AuthorDate: Mon Mar 30 13:35:29 2020 +0700 Converted anonymous IComparer<T> classes to use Comparer.Create() delegate method Related Work Items: #1 --- .../Analysis/Hunspell/Dictionary.cs | 98 ++++++++---------- .../Analysis/Hunspell/HunspellStemFilter.cs | 25 ++--- .../Dict/UserDictionary.cs | 14 +-- .../Tools/TokenInfoDictionaryBuilder.cs | 12 +-- .../Tools/UnknownDictionaryBuilder.cs | 16 ++- .../SortedSet/SortedSetDocValuesFacetCounts.cs | 18 +--- src/Lucene.Net.Facet/Taxonomy/TaxonomyFacets.cs | 31 ++---- .../PostingsHighlight/PostingsHighlighter.cs | 47 ++++----- .../VectorHighlight/BaseFragmentsBuilder.cs | 14 +-- .../Suggest/Analyzing/AnalyzingSuggester.cs | 10 +- .../Suggest/Analyzing/FreeTextSuggester.cs | 62 ++++-------- .../Suggest/Fst/WFSTCompletionLookup.cs | 16 +-- .../Suggest/SortedInputIterator.cs | 111 ++++++++++----------- .../Suggest/SortedTermFreqIteratorWrapper.cs | 58 +++++------ .../Analysis/Core/TestRandomChains.cs | 16 +-- src/Lucene.Net.Tests.Facet/FacetTestCase.cs | 57 ++--------- .../AllGroupHeadsCollectorTest.cs | 27 +---- .../DistinctValuesCollectorTest.cs | 49 ++++----- .../GroupFacetCollectorTest.cs | 79 ++++++--------- src/Lucene.Net.Tests.Grouping/TestGrouping.cs | 21 +--- src/Lucene.Net.Tests.Join/TestJoinUtil.cs | 35 ++----- src/Lucene.Net.Tests/Index/TestStressIndexing2.cs | 13 +-- src/Lucene.Net.Tests/Search/TestQueryRescorer.cs | 68 ++++--------- src/Lucene.Net.Tests/Search/TestSortRandom.cs | 83 +++++++-------- src/Lucene.Net.Tests/Search/TestSortRescorer.cs | 64 ++++-------- src/Lucene.Net.Tests/Util/Fst/TestFSTs.cs | 32 +----- src/Lucene.Net.Tests/Util/TestOfflineSorter.cs | 27 ++--- .../Codecs/Lucene3x/Lucene3xTermVectorsReader.cs | 19 +--- src/Lucene.Net/Index/BufferedUpdatesStream.cs | 13 +-- src/Lucene.Net/Index/ConcurrentMergeScheduler.cs | 29 ++---- src/Lucene.Net/Index/DocFieldProcessor.cs | 14 +-- src/Lucene.Net/Search/ConjunctionScorer.cs | 20 +--- src/Lucene.Net/Search/MinShouldMatchSumScorer.cs | 17 +--- src/Lucene.Net/Search/QueryRescorer.cs | 49 ++------- src/Lucene.Net/Search/SloppyPhraseScorer.cs | 19 +--- src/Lucene.Net/Search/SortRescorer.cs | 17 +--- src/Lucene.Net/Search/TopTermsRewrite.cs | 19 +--- src/Lucene.Net/Util/StringHelper.cs | 57 +++++------ src/Lucene.Net/Util/WAH8DocIdSet.cs | 24 ++--- 39 files changed, 427 insertions(+), 973 deletions(-) diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Hunspell/Dictionary.cs b/src/Lucene.Net.Analysis.Common/Analysis/Hunspell/Dictionary.cs index 20dcfa7..09f81cb 100644 --- a/src/Lucene.Net.Analysis.Common/Analysis/Hunspell/Dictionary.cs +++ b/src/Lucene.Net.Analysis.Common/Analysis/Hunspell/Dictionary.cs @@ -790,7 +790,48 @@ namespace Lucene.Net.Analysis.Hunspell FileInfo sorted = FileSupport.CreateTempFile("sorted", "dat", tempDir); - OfflineSorter sorter = new OfflineSorter(new ComparerAnonymousInnerClassHelper(this)); + OfflineSorter sorter = new OfflineSorter(Comparer<BytesRef>.Create((o1, o2) => + { + BytesRef scratch1 = new BytesRef(); + BytesRef scratch2 = new BytesRef(); + + scratch1.Bytes = o1.Bytes; + scratch1.Offset = o1.Offset; + scratch1.Length = o1.Length; + + for (int i = scratch1.Length - 1; i >= 0; i--) + { + if (scratch1.Bytes[scratch1.Offset + i] == this.FLAG_SEPARATOR) + { + scratch1.Length = i; + break; + } + } + + scratch2.Bytes = o2.Bytes; + scratch2.Offset = o2.Offset; + scratch2.Length = o2.Length; + + for (int i = scratch2.Length - 1; i >= 0; i--) + { + if (scratch2.Bytes[scratch2.Offset + i] == this.FLAG_SEPARATOR) + { + scratch2.Length = i; + break; + } + } + + int cmp = scratch1.CompareTo(scratch2); + if (cmp == 0) + { + // tie break on whole row + return o1.CompareTo(o2); + } + else + { + return cmp; + } + })); sorter.Sort(unsorted, sorted); try { @@ -897,61 +938,6 @@ namespace Lucene.Net.Analysis.Hunspell } } - private class ComparerAnonymousInnerClassHelper : IComparer<BytesRef> - { - private readonly Dictionary outerInstance; - - public ComparerAnonymousInnerClassHelper(Dictionary outerInstance) - { - this.outerInstance = outerInstance; - scratch1 = new BytesRef(); - scratch2 = new BytesRef(); - } - - internal BytesRef scratch1; - internal BytesRef scratch2; - - public virtual int Compare(BytesRef o1, BytesRef o2) - { - scratch1.Bytes = o1.Bytes; - scratch1.Offset = o1.Offset; - scratch1.Length = o1.Length; - - for (int i = scratch1.Length - 1; i >= 0; i--) - { - if (scratch1.Bytes[scratch1.Offset + i] == outerInstance.FLAG_SEPARATOR) - { - scratch1.Length = i; - break; - } - } - - scratch2.Bytes = o2.Bytes; - scratch2.Offset = o2.Offset; - scratch2.Length = o2.Length; - - for (int i = scratch2.Length - 1; i >= 0; i--) - { - if (scratch2.Bytes[scratch2.Offset + i] == outerInstance.FLAG_SEPARATOR) - { - scratch2.Length = i; - break; - } - } - - int cmp = scratch1.CompareTo(scratch2); - if (cmp == 0) - { - // tie break on whole row - return o1.CompareTo(o2); - } - else - { - return cmp; - } - } - } - internal static char[] DecodeFlags(BytesRef b) { if (b.Length == 0) diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Hunspell/HunspellStemFilter.cs b/src/Lucene.Net.Analysis.Common/Analysis/Hunspell/HunspellStemFilter.cs index d7f3c97..28adb03 100644 --- a/src/Lucene.Net.Analysis.Common/Analysis/Hunspell/HunspellStemFilter.cs +++ b/src/Lucene.Net.Analysis.Common/Analysis/Hunspell/HunspellStemFilter.cs @@ -75,7 +75,7 @@ namespace Lucene.Net.Analysis.Hunspell /// <param name="dictionary"> Hunspell <see cref="Dictionary"/> containing the affix rules and words that will be used to stem the tokens </param> /// <param name="dedup"> remove duplicates </param> /// <param name="longestOnly"> true if only the longest term should be output. </param> - public HunspellStemFilter(TokenStream input, Dictionary dictionary, bool dedup, bool longestOnly) + public HunspellStemFilter(TokenStream input, Dictionary dictionary, bool dedup, bool longestOnly) : base(input) { this.dedup = dedup && longestOnly == false; // don't waste time deduping if longestOnly is set @@ -145,26 +145,17 @@ namespace Lucene.Net.Analysis.Hunspell buffer = null; } - internal static readonly IComparer<CharsRef> lengthComparer = new ComparerAnonymousInnerClassHelper(); - - private class ComparerAnonymousInnerClassHelper : IComparer<CharsRef> + internal static readonly IComparer<CharsRef> lengthComparer = Comparer<CharsRef>.Create((o1, o2) => { - public ComparerAnonymousInnerClassHelper() + if (o2.Length == o1.Length) { + // tie break on text + return o2.CompareTo(o1); } - - public virtual int Compare(CharsRef o1, CharsRef o2) + else { - if (o2.Length == o1.Length) - { - // tie break on text - return o2.CompareTo(o1); - } - else - { - return o2.Length < o1.Length ? -1 : 1; - } + return o2.Length < o1.Length ? -1 : 1; } - } + }); } } \ No newline at end of file diff --git a/src/Lucene.Net.Analysis.Kuromoji/Dict/UserDictionary.cs b/src/Lucene.Net.Analysis.Kuromoji/Dict/UserDictionary.cs index 2017217..a6c7655 100644 --- a/src/Lucene.Net.Analysis.Kuromoji/Dict/UserDictionary.cs +++ b/src/Lucene.Net.Analysis.Kuromoji/Dict/UserDictionary.cs @@ -77,7 +77,7 @@ namespace Lucene.Net.Analysis.Ja.Dict // TODO: should we allow multiple segmentations per input 'phrase'? // the old treemap didn't support this either, and i'm not sure if its needed/useful? - featureEntries.Sort(new ComparerAnonymousHelper()); + featureEntries.Sort(Comparer<string[]>.Create((left, right) => left[0].CompareToOrdinal(right[0]))); List<string> data = new List<string>(featureEntries.Count); List<int[]> segmentations = new List<int[]>(featureEntries.Count); @@ -124,17 +124,7 @@ namespace Lucene.Net.Analysis.Ja.Dict this.data = data.ToArray(/*new string[data.Count]*/); this.segmentations = segmentations.ToArray(/*new int[segmentations.Count][]*/); } - - // LUCENENET TODO: Make an AnonymousComparer class in Support and - // replace all of these classes. - private class ComparerAnonymousHelper : IComparer<string[]> - { - public int Compare(string[] left, string[] right) - { - return left[0].CompareToOrdinal(right[0]); - } - } - + /// <summary> /// Lookup words in text. /// </summary> diff --git a/src/Lucene.Net.Analysis.Kuromoji/Tools/TokenInfoDictionaryBuilder.cs b/src/Lucene.Net.Analysis.Kuromoji/Tools/TokenInfoDictionaryBuilder.cs index 5c5e62e..31ccf90 100644 --- a/src/Lucene.Net.Analysis.Kuromoji/Tools/TokenInfoDictionaryBuilder.cs +++ b/src/Lucene.Net.Analysis.Kuromoji/Tools/TokenInfoDictionaryBuilder.cs @@ -112,7 +112,7 @@ namespace Lucene.Net.Analysis.Ja.Util Console.WriteLine(" sort..."); // sort by term: we sorted the files already and use a stable sort. - lines.Sort(new ComparerAnonymousHelper()); + lines.Sort(Comparer<string[]>.Create((left, right) => left[0].CompareToOrdinal(right[0]))); Console.WriteLine(" encode..."); @@ -159,15 +159,7 @@ namespace Lucene.Net.Analysis.Ja.Util return dictionary; } - - private class ComparerAnonymousHelper : IComparer<string[]> - { - public int Compare(string[] left, string[] right) - { - return left[0].CompareToOrdinal(right[0]); - } - } - + /// <summary> /// IPADIC features /// diff --git a/src/Lucene.Net.Analysis.Kuromoji/Tools/UnknownDictionaryBuilder.cs b/src/Lucene.Net.Analysis.Kuromoji/Tools/UnknownDictionaryBuilder.cs index 5529769..f5b776a 100644 --- a/src/Lucene.Net.Analysis.Kuromoji/Tools/UnknownDictionaryBuilder.cs +++ b/src/Lucene.Net.Analysis.Kuromoji/Tools/UnknownDictionaryBuilder.cs @@ -72,7 +72,12 @@ namespace Lucene.Net.Analysis.Ja.Util } } - lines.Sort(new ComparerAnonymousHelper()); + lines.Sort(Comparer<string[]>.Create((left, right) => + { + int leftId = CharacterDefinition.LookupCharacterClass(left[0]); + int rightId = CharacterDefinition.LookupCharacterClass(right[0]); + return leftId - rightId; + })); foreach (string[] entry in lines) { @@ -81,15 +86,6 @@ namespace Lucene.Net.Analysis.Ja.Util return dictionary; } - private class ComparerAnonymousHelper : IComparer<string[]> - { - public int Compare(string[] left, string[] right) - { - int leftId = CharacterDefinition.LookupCharacterClass(left[0]); - int rightId = CharacterDefinition.LookupCharacterClass(right[0]); - return leftId - rightId; - } - } public virtual void ReadCharacterDefinition(string filename, UnknownDictionaryWriter dictionary) { diff --git a/src/Lucene.Net.Facet/SortedSet/SortedSetDocValuesFacetCounts.cs b/src/Lucene.Net.Facet/SortedSet/SortedSetDocValuesFacetCounts.cs index 1f4fd5e..0fc7fb7 100644 --- a/src/Lucene.Net.Facet/SortedSet/SortedSetDocValuesFacetCounts.cs +++ b/src/Lucene.Net.Facet/SortedSet/SortedSetDocValuesFacetCounts.cs @@ -303,20 +303,7 @@ namespace Lucene.Net.Facet.SortedSet } // Sort by highest count: - results.Sort(new ComparerAnonymousInnerClassHelper(this)); - return results; - } - - private class ComparerAnonymousInnerClassHelper : IComparer<FacetResult> - { - private readonly SortedSetDocValuesFacetCounts outerInstance; - - public ComparerAnonymousInnerClassHelper(SortedSetDocValuesFacetCounts outerInstance) - { - this.outerInstance = outerInstance; - } - - public virtual int Compare(FacetResult a, FacetResult b) + results.Sort(Comparer<FacetResult>.Create((a, b) => { if ((int)a.Value > (int)b.Value) { @@ -330,7 +317,8 @@ namespace Lucene.Net.Facet.SortedSet { return a.Dim.CompareToOrdinal(b.Dim); } - } + })); + return results; } } } \ No newline at end of file diff --git a/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacets.cs b/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacets.cs index e5eabcf..f4bbb30 100644 --- a/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacets.cs +++ b/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacets.cs @@ -28,31 +28,22 @@ namespace Lucene.Net.Facet.Taxonomy /// </summary> public abstract class TaxonomyFacets : Facets { - private static readonly IComparer<FacetResult> BY_VALUE_THEN_DIM = new ComparerAnonymousInnerClassHelper(); - - private class ComparerAnonymousInnerClassHelper : IComparer<FacetResult> + private static readonly IComparer<FacetResult> BY_VALUE_THEN_DIM = Comparer<FacetResult>.Create((a, b) => { - public ComparerAnonymousInnerClassHelper() + if (a.Value > b.Value) { + return -1; } - - public virtual int Compare(FacetResult a, FacetResult b) + else if (b.Value > a.Value) { - if (a.Value > b.Value) - { - return -1; - } - else if (b.Value > a.Value) - { - return 1; - } - else - { - return a.Dim.CompareToOrdinal(b.Dim); - } + return 1; } - } - + else + { + return a.Dim.CompareToOrdinal(b.Dim); + } + }); + /// <summary> /// Index field name provided to the constructor. /// </summary> diff --git a/src/Lucene.Net.Highlighter/PostingsHighlight/PostingsHighlighter.cs b/src/Lucene.Net.Highlighter/PostingsHighlight/PostingsHighlighter.cs index 0224926..be4c410 100644 --- a/src/Lucene.Net.Highlighter/PostingsHighlight/PostingsHighlighter.cs +++ b/src/Lucene.Net.Highlighter/PostingsHighlight/PostingsHighlighter.cs @@ -584,34 +584,7 @@ namespace Lucene.Net.Search.PostingsHighlight return highlights; } - - internal class HighlightDocComparerAnonymousHelper1 : IComparer<Passage> - { - public int Compare(Passage left, Passage right) - { - if (left.score < right.score) - { - return -1; - } - else if (left.score > right.score) - { - return 1; - } - else - { - return left.startOffset - right.startOffset; - } - } - } - - internal class HighlightDocComparerAnonymousHelper2 : IComparer<Passage> - { - public int Compare(Passage left, Passage right) - { - return left.startOffset - right.startOffset; - } - } - + // algorithm: treat sentence snippets as miniature documents // we can intersect these with the postings lists via BreakIterator.preceding(offset),s // score each sentence as norm(sentenceStartOffset) * sum(weight * tf(freq)) @@ -668,7 +641,21 @@ namespace Lucene.Net.Search.PostingsHighlight pq.Add(new OffsetsEnum(EMPTY, int.MaxValue)); // a sentinel for termination - JCG.PriorityQueue<Passage> passageQueue = new JCG.PriorityQueue<Passage>(n, new HighlightDocComparerAnonymousHelper1()); + JCG.PriorityQueue<Passage> passageQueue = new JCG.PriorityQueue<Passage>(n, Comparer<Passage>.Create((left, right) => + { + if (left.score < right.score) + { + return -1; + } + else if (left.score > right.score) + { + return 1; + } + else + { + return left.startOffset - right.startOffset; + } + })); Passage current = new Passage(); while (pq.TryDequeue(out OffsetsEnum off)) @@ -722,7 +709,7 @@ namespace Lucene.Net.Search.PostingsHighlight p.Sort(); } // sort in ascending order - ArrayUtil.TimSort(passages, new HighlightDocComparerAnonymousHelper2()); + ArrayUtil.TimSort(passages, Comparer<Passage>.Create((left, right) => left.startOffset - right.startOffset)); return passages; } // advance breakiterator diff --git a/src/Lucene.Net.Highlighter/VectorHighlight/BaseFragmentsBuilder.cs b/src/Lucene.Net.Highlighter/VectorHighlight/BaseFragmentsBuilder.cs index 51b38ad..ad88f4d 100644 --- a/src/Lucene.Net.Highlighter/VectorHighlight/BaseFragmentsBuilder.cs +++ b/src/Lucene.Net.Highlighter/VectorHighlight/BaseFragmentsBuilder.cs @@ -342,7 +342,7 @@ namespace Lucene.Net.Search.VectorHighlight WeightedFragInfo weightedFragInfo = new WeightedFragInfo(fragStart, fragEnd, subInfos, boost); fieldNameToFragInfos[field.Name].Add(weightedFragInfo); } - fragInfos_continue: { } + fragInfos_continue: { } } List<WeightedFragInfo> result = new List<WeightedFragInfo>(); @@ -350,19 +350,11 @@ namespace Lucene.Net.Search.VectorHighlight { result.AddRange(weightedFragInfos); } - CollectionUtil.TimSort(result, new DiscreteMultiValueHighlightingComparerAnonymousHelper()); + CollectionUtil.TimSort(result, Comparer<WeightedFragInfo>.Create((info1, info2) => info1.StartOffset - info2.StartOffset)); return result; } - - internal class DiscreteMultiValueHighlightingComparerAnonymousHelper : IComparer<WeightedFragInfo> - { - public int Compare(WeightedFragInfo info1, WeightedFragInfo info2) - { - return info1.StartOffset - info2.StartOffset; - } - } - + public virtual char MultiValuedSeparator { get { return multiValuedSeparator; } diff --git a/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingSuggester.cs b/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingSuggester.cs index 5076209..3a422bc 100644 --- a/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingSuggester.cs +++ b/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingSuggester.cs @@ -1034,14 +1034,6 @@ namespace Lucene.Net.Search.Suggest.Analyzing } internal static readonly IComparer<PairOutputs<long?, BytesRef>.Pair> weightComparer = - new ComparerAnonymousInnerClassHelper(); - - private sealed class ComparerAnonymousInnerClassHelper : IComparer<PairOutputs<long?, BytesRef>.Pair> - { - public int Compare(PairOutputs<long?, BytesRef>.Pair left, PairOutputs<long?, BytesRef>.Pair right) - { - return Comparer<long?>.Default.Compare(left.Output1, right.Output1); - } - } + Comparer<PairOutputs<long?, BytesRef>.Pair>.Create((left, right) => Comparer<long?>.Default.Compare(left.Output1, right.Output1)); } } \ No newline at end of file diff --git a/src/Lucene.Net.Suggest/Suggest/Analyzing/FreeTextSuggester.cs b/src/Lucene.Net.Suggest/Suggest/Analyzing/FreeTextSuggester.cs index c7fdab5..7ee9bc1 100644 --- a/src/Lucene.Net.Suggest/Suggest/Analyzing/FreeTextSuggester.cs +++ b/src/Lucene.Net.Suggest/Suggest/Analyzing/FreeTextSuggester.cs @@ -780,13 +780,28 @@ namespace Lucene.Net.Search.Suggest.Analyzing (long)(long.MaxValue * (decimal)backoff * ((decimal)DecodeWeight(completion.Output)) / contextCount)); results.Add(result); Debug.Assert(results.Count == seen.Count); - //System.out.println(" add result=" + result); - nextCompletionContinue:; + //System.out.println(" add result=" + result); + nextCompletionContinue:; } backoff *= ALPHA; } - results.Sort(new ComparerAnonymousInnerClassHelper(this)); + results.Sort(Comparer<Lookup.LookupResult>.Create((a, b) => + { + if (a.Value > b.Value) + { + return -1; + } + else if (a.Value < b.Value) + { + return 1; + } + else + { + // Tie break by UTF16 sort order: + return a.Key.CompareToOrdinal(b.Key); + } + })); if (results.Count > num) { @@ -854,33 +869,6 @@ namespace Lucene.Net.Search.Suggest.Analyzing } } - private sealed class ComparerAnonymousInnerClassHelper : IComparer<Lookup.LookupResult> - { - private readonly FreeTextSuggester outerInstance; - - public ComparerAnonymousInnerClassHelper(FreeTextSuggester outerInstance) - { - this.outerInstance = outerInstance; - } - - public int Compare(LookupResult a, LookupResult b) - { - if (a.Value > b.Value) - { - return -1; - } - else if (a.Value < b.Value) - { - return 1; - } - else - { - // Tie break by UTF16 sort order: - return a.Key.CompareToOrdinal(b.Key); - } - } - } - /// <summary> /// weight -> cost </summary> private long EncodeWeight(long ngramCount) @@ -923,19 +911,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing return output; } - internal static readonly IComparer<long?> weightComparer = new ComparerAnonymousInnerClassHelper2(); - - private sealed class ComparerAnonymousInnerClassHelper2 : IComparer<long?> - { - public ComparerAnonymousInnerClassHelper2() - { - } - - public int Compare(long? left, long? right) - { - return Comparer<long?>.Default.Compare(left, right); - } - } + internal static readonly IComparer<long?> weightComparer = Comparer<long?>.Create((left, right) => Comparer<long?>.Default.Compare(left, right)); /// <summary> /// Returns the weight associated with an input string, diff --git a/src/Lucene.Net.Suggest/Suggest/Fst/WFSTCompletionLookup.cs b/src/Lucene.Net.Suggest/Suggest/Fst/WFSTCompletionLookup.cs index 61febac..d045ec7 100644 --- a/src/Lucene.Net.Suggest/Suggest/Fst/WFSTCompletionLookup.cs +++ b/src/Lucene.Net.Suggest/Suggest/Fst/WFSTCompletionLookup.cs @@ -316,20 +316,8 @@ namespace Lucene.Net.Search.Suggest.Fst } } - internal static readonly IComparer<long?> weightComparer = new ComparerAnonymousInnerClassHelper(); - - private class ComparerAnonymousInnerClassHelper : IComparer<long?> - { - public ComparerAnonymousInnerClassHelper() - { - } - - public virtual int Compare(long? left, long? right) - { - return Comparer<long?>.Default.Compare(left, right); - } - } - + internal static readonly IComparer<long?> weightComparer = Comparer<long?>.Create((left, right) => Comparer<long?>.Default.Compare(left, right)); + /// <summary> /// Returns byte size of the underlying FST. </summary> public override long GetSizeInBytes() diff --git a/src/Lucene.Net.Suggest/Suggest/SortedInputIterator.cs b/src/Lucene.Net.Suggest/Suggest/SortedInputIterator.cs index 3b4fb4c..61f546c 100644 --- a/src/Lucene.Net.Suggest/Suggest/SortedInputIterator.cs +++ b/src/Lucene.Net.Suggest/Suggest/SortedInputIterator.cs @@ -61,7 +61,52 @@ namespace Lucene.Net.Search.Suggest /// </summary> public SortedInputIterator(IInputIterator source, IComparer<BytesRef> comparer) { - this.tieBreakByCostComparer = new ComparerAnonymousInnerClassHelper(this); + this.tieBreakByCostComparer = Comparer<BytesRef>.Create((left, right) => + { + SortedInputIterator outerInstance = this; + + BytesRef leftScratch = new BytesRef(); + BytesRef rightScratch = new BytesRef(); + ByteArrayDataInput input = new ByteArrayDataInput(); + // Make shallow copy in case decode changes the BytesRef: + leftScratch.Bytes = left.Bytes; + leftScratch.Offset = left.Offset; + leftScratch.Length = left.Length; + rightScratch.Bytes = right.Bytes; + rightScratch.Offset = right.Offset; + rightScratch.Length = right.Length; + long leftCost = outerInstance.Decode(leftScratch, input); + long rightCost = outerInstance.Decode(rightScratch, input); + if (outerInstance.HasPayloads) + { + outerInstance.DecodePayload(leftScratch, input); + outerInstance.DecodePayload(rightScratch, input); + } + if (outerInstance.HasContexts) + { + outerInstance.DecodeContexts(leftScratch, input); + outerInstance.DecodeContexts(rightScratch, input); + } + // LUCENENET NOTE: outerInstance.Comparer != outerInstance.comparer!! + int cmp = outerInstance.comparer.Compare(leftScratch, rightScratch); + if (cmp != 0) + { + return cmp; + } + if (leftCost < rightCost) + { + return -1; + } + else if (leftCost > rightCost) + { + return 1; + } + else + { + return 0; + } + }); + this.hasPayloads = source.HasPayloads; this.hasContexts = source.HasContexts; this.source = source; @@ -150,63 +195,7 @@ namespace Lucene.Net.Search.Suggest /// <summary> /// Sortes by BytesRef (ascending) then cost (ascending). </summary> private readonly IComparer<BytesRef> tieBreakByCostComparer; - - private class ComparerAnonymousInnerClassHelper : IComparer<BytesRef> - { - private readonly SortedInputIterator outerInstance; - public ComparerAnonymousInnerClassHelper(SortedInputIterator outerInstance) - { - this.outerInstance = outerInstance; - } - - - private readonly BytesRef leftScratch = new BytesRef(); - private readonly BytesRef rightScratch = new BytesRef(); - private readonly ByteArrayDataInput input = new ByteArrayDataInput(); - - public virtual int Compare(BytesRef left, BytesRef right) - { - // Make shallow copy in case decode changes the BytesRef: - leftScratch.Bytes = left.Bytes; - leftScratch.Offset = left.Offset; - leftScratch.Length = left.Length; - rightScratch.Bytes = right.Bytes; - rightScratch.Offset = right.Offset; - rightScratch.Length = right.Length; - long leftCost = outerInstance.Decode(leftScratch, input); - long rightCost = outerInstance.Decode(rightScratch, input); - if (outerInstance.HasPayloads) - { - outerInstance.DecodePayload(leftScratch, input); - outerInstance.DecodePayload(rightScratch, input); - } - if (outerInstance.HasContexts) - { - outerInstance.DecodeContexts(leftScratch, input); - outerInstance.DecodeContexts(rightScratch, input); - } - // LUCENENET NOTE: outerInstance.Comparer != outerInstance.comparer!! - int cmp = outerInstance.comparer.Compare(leftScratch, rightScratch); - if (cmp != 0) - { - return cmp; - } - if (leftCost < rightCost) - { - return -1; - } - else if (leftCost > rightCost) - { - return 1; - } - else - { - return 0; - } - - } - } - + private OfflineSorter.ByteSequencesReader Sort() { string prefix = this.GetType().Name; @@ -269,8 +258,8 @@ namespace Lucene.Net.Search.Suggest /// <summary> /// encodes an entry (bytes+(contexts)+(payload)+weight) to the provided writer /// </summary> - protected internal virtual void Encode(OfflineSorter.ByteSequencesWriter writer, - ByteArrayDataOutput output, byte[] buffer, BytesRef spare, BytesRef payload, + protected internal virtual void Encode(OfflineSorter.ByteSequencesWriter writer, + ByteArrayDataOutput output, byte[] buffer, BytesRef spare, BytesRef payload, IEnumerable<BytesRef> contexts, long weight) { int requiredLength = spare.Length + 8 + ((hasPayloads) ? 2 + payload.Length : 0); @@ -335,7 +324,7 @@ namespace Lucene.Net.Search.Suggest BytesRef contextSpare = new BytesRef(curContextLength); tmpInput.ReadBytes(contextSpare.Bytes, 0, curContextLength); contextSpare.Length = curContextLength; - contextSet.Add(contextSpare); + contextSet.Add(contextSpare); scratch.Length -= curContextLength; } diff --git a/src/Lucene.Net.Suggest/Suggest/SortedTermFreqIteratorWrapper.cs b/src/Lucene.Net.Suggest/Suggest/SortedTermFreqIteratorWrapper.cs index 7f0fc99..36d1a4a 100644 --- a/src/Lucene.Net.Suggest/Suggest/SortedTermFreqIteratorWrapper.cs +++ b/src/Lucene.Net.Suggest/Suggest/SortedTermFreqIteratorWrapper.cs @@ -59,7 +59,29 @@ namespace Lucene.Net.Search.Suggest this.source = source; this.comparer = comparer; this.reader = Sort(); - this.tieBreakByCostComparer = new ComparerAnonymousInnerClassHelper(this); + this.tieBreakByCostComparer = Comparer<BytesRef>.Create((left, right) => + { + SortedTermFreqIteratorWrapper outerInstance = this; + BytesRef leftScratch = new BytesRef(); + BytesRef rightScratch = new BytesRef(); + + ByteArrayDataInput input = new ByteArrayDataInput(); + // Make shallow copy in case decode changes the BytesRef: + leftScratch.Bytes = left.Bytes; + leftScratch.Offset = left.Offset; + leftScratch.Length = left.Length; + rightScratch.Bytes = right.Bytes; + rightScratch.Offset = right.Offset; + rightScratch.Length = right.Length; + long leftCost = outerInstance.Decode(leftScratch, input); + long rightCost = outerInstance.Decode(rightScratch, input); + int cmp = outerInstance.comparer.Compare(leftScratch, rightScratch); + if (cmp != 0) + { + return cmp; + } + return leftCost.CompareTo(rightCost); + }); } public virtual IComparer<BytesRef> Comparer @@ -110,38 +132,6 @@ namespace Lucene.Net.Search.Suggest /// </summary> private readonly IComparer<BytesRef> tieBreakByCostComparer; - private class ComparerAnonymousInnerClassHelper : IComparer<BytesRef> - { - public ComparerAnonymousInnerClassHelper(SortedTermFreqIteratorWrapper outerInstance) - { - this.outerInstance = outerInstance; - } - private readonly SortedTermFreqIteratorWrapper outerInstance; - - private readonly BytesRef leftScratch = new BytesRef(); - private readonly BytesRef rightScratch = new BytesRef(); - private readonly ByteArrayDataInput input = new ByteArrayDataInput(); - - public virtual int Compare(BytesRef left, BytesRef right) - { - // Make shallow copy in case decode changes the BytesRef: - leftScratch.Bytes = left.Bytes; - leftScratch.Offset = left.Offset; - leftScratch.Length = left.Length; - rightScratch.Bytes = right.Bytes; - rightScratch.Offset = right.Offset; - rightScratch.Length = right.Length; - long leftCost = outerInstance.Decode(leftScratch, input); - long rightCost = outerInstance.Decode(rightScratch, input); - int cmp = outerInstance.comparer.Compare(leftScratch, rightScratch); - if (cmp != 0) - { - return cmp; - } - return leftCost.CompareTo(rightCost); - } - } - private OfflineSorter.ByteSequencesReader Sort() { string prefix = this.GetType().Name; @@ -204,7 +194,7 @@ namespace Lucene.Net.Search.Suggest /// <summary> /// encodes an entry (bytes+weight) to the provided writer /// </summary> - protected internal virtual void Encode(OfflineSorter.ByteSequencesWriter writer, + protected internal virtual void Encode(OfflineSorter.ByteSequencesWriter writer, ByteArrayDataOutput output, byte[] buffer, BytesRef spare, long weight) { if (spare.Length + 8 >= buffer.Length) 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 3e529e5..c59ed19 100644 --- a/src/Lucene.Net.Tests.Analysis.Common/Analysis/Core/TestRandomChains.cs +++ b/src/Lucene.Net.Tests.Analysis.Common/Analysis/Core/TestRandomChains.cs @@ -244,7 +244,7 @@ namespace Lucene.Net.Analysis.Core } } - IComparer<ConstructorInfo> ctorComp = new ComparerAnonymousInnerClassHelper(); + IComparer<ConstructorInfo> ctorComp = Comparer<ConstructorInfo>.Create((arg0, arg1)=> arg0.ToString().CompareToOrdinal(arg1.ToString())); tokenizers.Sort(ctorComp); tokenfilters.Sort(ctorComp); charfilters.Sort(ctorComp); @@ -255,19 +255,7 @@ namespace Lucene.Net.Analysis.Core Console.WriteLine("charfilters = " + charfilters); } } - - private class ComparerAnonymousInnerClassHelper : IComparer<ConstructorInfo> - { - public ComparerAnonymousInnerClassHelper() - { - } - - public virtual int Compare(ConstructorInfo arg0, ConstructorInfo arg1) - { - return arg0.ToString().CompareToOrdinal(arg1.ToString()); - } - } - + [OneTimeTearDown] public override void AfterClass() { diff --git a/src/Lucene.Net.Tests.Facet/FacetTestCase.cs b/src/Lucene.Net.Tests.Facet/FacetTestCase.cs index f077a4a..08eeb9f 100644 --- a/src/Lucene.Net.Tests.Facet/FacetTestCase.cs +++ b/src/Lucene.Net.Tests.Facet/FacetTestCase.cs @@ -152,7 +152,10 @@ namespace Lucene.Net.Facet { if (numInRow > 1) { - Array.Sort(labelValues, i - numInRow, i - (i - numInRow), new ComparerAnonymousInnerClassHelper(this)); + Array.Sort(labelValues, i - numInRow, i - (i - numInRow), Comparer<LabelAndValue>.Create((a,b)=> { + Debug.Assert((double)a.Value == (double)b.Value); + return (new BytesRef(a.Label)).CompareTo(new BytesRef(b.Label)); + })); } numInRow = 1; if (i < labelValues.Length) @@ -163,39 +166,10 @@ namespace Lucene.Net.Facet i++; } } - - private class ComparerAnonymousInnerClassHelper : IComparer<LabelAndValue> - { - private readonly FacetTestCase outerInstance; - - public ComparerAnonymousInnerClassHelper(FacetTestCase outerInstance) - { - this.outerInstance = outerInstance; - } - - public virtual int Compare(LabelAndValue a, LabelAndValue b) - { - Debug.Assert((double)a.Value == (double)b.Value); - return (new BytesRef(a.Label)).CompareTo(new BytesRef(b.Label)); - } - } - + protected internal virtual void SortLabelValues(List<LabelAndValue> labelValues) { - labelValues.Sort(new ComparerAnonymousInnerClassHelper2(this)); - } - - private class ComparerAnonymousInnerClassHelper2 : IComparer<LabelAndValue> - { - private readonly FacetTestCase outerInstance; - - public ComparerAnonymousInnerClassHelper2(FacetTestCase outerInstance) - { - this.outerInstance = outerInstance; - } - - public virtual int Compare(LabelAndValue a, LabelAndValue b) - { + labelValues.Sort(Comparer<LabelAndValue>.Create((a,b)=> { if ((double)a.Value > (double)b.Value) { return -1; @@ -208,24 +182,13 @@ namespace Lucene.Net.Facet { return (new BytesRef(a.Label)).CompareTo(new BytesRef(b.Label)); } - } + })); } + protected internal virtual void SortFacetResults(List<FacetResult> results) { - results.Sort(new ComparerAnonymousInnerClassHelper3(this)); - } - - private class ComparerAnonymousInnerClassHelper3 : IComparer<FacetResult> - { - private readonly FacetTestCase outerInstance; - - public ComparerAnonymousInnerClassHelper3(FacetTestCase outerInstance) - { - this.outerInstance = outerInstance; - } - - public virtual int Compare(FacetResult a, FacetResult b) + results.Sort(Comparer<FacetResult>.Create((a, b) => { if ((double)a.Value > (double)b.Value) { @@ -239,7 +202,7 @@ namespace Lucene.Net.Facet { return 0; } - } + })); } protected internal virtual void AssertFloatValuesEquals(IList<FacetResult> a, IList<FacetResult> b) diff --git a/src/Lucene.Net.Tests.Grouping/AllGroupHeadsCollectorTest.cs b/src/Lucene.Net.Tests.Grouping/AllGroupHeadsCollectorTest.cs index 5c69335..6f73ce0 100644 --- a/src/Lucene.Net.Tests.Grouping/AllGroupHeadsCollectorTest.cs +++ b/src/Lucene.Net.Tests.Grouping/AllGroupHeadsCollectorTest.cs @@ -557,23 +557,10 @@ namespace Lucene.Net.Search.Grouping return new Sort(sortFields.ToArray(/*new SortField[sortFields.size()]*/)); } - internal class ComparerAnonymousHelper : IComparer<GroupDoc> + private IComparer<GroupDoc> GetComparer(Sort sort, bool sortByScoreOnly, int[] fieldIdToDocID) { - private readonly AllGroupHeadsCollectorTest outerInstance; - private readonly SortField[] sortFields; - private readonly bool sortByScoreOnly; - private readonly int[] fieldIdToDocID; - - public ComparerAnonymousHelper(AllGroupHeadsCollectorTest outerInstance, SortField[] sortFields, bool sortByScoreOnly, int[] fieldIdToDocID) - { - this.outerInstance = outerInstance; - this.sortFields = sortFields; - this.sortByScoreOnly = sortByScoreOnly; - this.fieldIdToDocID = fieldIdToDocID; - } - - public int Compare(GroupDoc d1, GroupDoc d2) - { + SortField[] sortFields = sort.GetSort(); + return Comparer<GroupDoc>.Create((d1,d2)=> { foreach (SortField sf in sortFields) { int cmp; @@ -617,13 +604,7 @@ namespace Lucene.Net.Search.Grouping // Our sort always fully tie breaks: fail(); return 0; - } - } - - private IComparer<GroupDoc> GetComparer(Sort sort, bool sortByScoreOnly, int[] fieldIdToDocID) - { - SortField[] sortFields = sort.GetSort(); - return new ComparerAnonymousHelper(this, sortFields, sortByScoreOnly, fieldIdToDocID); + }); } private AbstractAllGroupHeadsCollector CreateRandomCollector(string groupField, Sort sortWithinGroup, bool canUseIDV, DocValuesType valueType) diff --git a/src/Lucene.Net.Tests.Grouping/DistinctValuesCollectorTest.cs b/src/Lucene.Net.Tests.Grouping/DistinctValuesCollectorTest.cs index 23755c9..171eb19 100644 --- a/src/Lucene.Net.Tests.Grouping/DistinctValuesCollectorTest.cs +++ b/src/Lucene.Net.Tests.Grouping/DistinctValuesCollectorTest.cs @@ -45,36 +45,6 @@ namespace Lucene.Net.Search.Grouping private readonly string countField = "publisher"; //private readonly string dvCountField = "publisher_dv"; // LUCENENET NOTE: Not used in Lucene - internal class ComparerAnonymousHelper1 : IComparer<AbstractDistinctValuesCollector.IGroupCount<IComparable>> - { - private readonly DistinctValuesCollectorTest outerInstance; - - public ComparerAnonymousHelper1(DistinctValuesCollectorTest outerInstance) - { - this.outerInstance = outerInstance; - } - - public int Compare(AbstractDistinctValuesCollector.IGroupCount<IComparable> groupCount1, AbstractDistinctValuesCollector.IGroupCount<IComparable> groupCount2) - { - if (groupCount1.GroupValue == null) - { - if (groupCount2.GroupValue == null) - { - return 0; - } - return -1; - } - else if (groupCount2.GroupValue == null) - { - return 1; - } - else - { - return groupCount1.GroupValue.CompareTo(groupCount2.GroupValue); - } - } - } - [Test] public virtual void TestSimple() { @@ -150,7 +120,24 @@ namespace Lucene.Net.Search.Grouping IndexSearcher indexSearcher = NewSearcher(w.GetReader()); w.Dispose(); - var cmp = new ComparerAnonymousHelper1(this); + var cmp = Comparer<AbstractDistinctValuesCollector.IGroupCount<IComparable>>.Create((groupCount1, groupCount2) => { + if (groupCount1.GroupValue == null) + { + if (groupCount2.GroupValue == null) + { + return 0; + } + return -1; + } + else if (groupCount2.GroupValue == null) + { + return 1; + } + else + { + return groupCount1.GroupValue.CompareTo(groupCount2.GroupValue); + } + }); // === Search for content:random IAbstractFirstPassGroupingCollector<IComparable> firstCollector = CreateRandomFirstPassCollector(dvType, new Sort(), groupField, 10); diff --git a/src/Lucene.Net.Tests.Grouping/GroupFacetCollectorTest.cs b/src/Lucene.Net.Tests.Grouping/GroupFacetCollectorTest.cs index eaca33d..09ef1e6 100644 --- a/src/Lucene.Net.Tests.Grouping/GroupFacetCollectorTest.cs +++ b/src/Lucene.Net.Tests.Grouping/GroupFacetCollectorTest.cs @@ -496,29 +496,6 @@ namespace Lucene.Net.Search.Grouping } } - internal class ComparerAnonymousHelper1 : IComparer<string> - { - public int Compare(string a, string b) - { - if (a == b) - { - return 0; - } - else if (a == null) - { - return -1; - } - else if (b == null) - { - return 1; - } - else - { - return a.CompareToOrdinal(b); - } - } - } - private IndexContext CreateIndexContext(bool multipleFacetValuesPerDocument) { Random random = Random; @@ -608,8 +585,25 @@ namespace Lucene.Net.Search.Grouping docNoFacet.Add(content); docNoGroupNoFacet.Add(content); - ISet<string> uniqueFacetValues = new JCG.SortedSet<string>(new ComparerAnonymousHelper1()); - + ISet<string> uniqueFacetValues = new JCG.SortedSet<string>(Comparer<string>.Create((a, b) => { + if (a == b) + { + return 0; + } + else if (a == null) + { + return -1; + } + else if (b == null) + { + return 1; + } + else + { + return a.CompareToOrdinal(b); + } + })); + // LUCENENET NOTE: Need JCG.Dictionary here because of null keys IDictionary<string, JCG.Dictionary<string, ISet<string>>> searchTermToFacetToGroups = new Dictionary<string, JCG.Dictionary<string, ISet<string>>>(); int facetWithMostGroups = 0; @@ -737,29 +731,6 @@ namespace Lucene.Net.Search.Grouping return new IndexContext(searchTermToFacetToGroups, reader, numDocs, dir, facetWithMostGroups, numGroups, contentBrs, uniqueFacetValues, useDv); } - internal class ComparerAnonymousHelper2 : IComparer<TermGroupFacetCollector.FacetEntry> - { - private readonly bool orderByCount; - - public ComparerAnonymousHelper2(bool orderByCount) - { - this.orderByCount = orderByCount; - } - - public int Compare(AbstractGroupFacetCollector.FacetEntry a, AbstractGroupFacetCollector.FacetEntry b) - { - if (orderByCount) - { - int cmp = b.Count - a.Count; - if (cmp != 0) - { - return cmp; - } - } - return a.Value.CompareTo(b.Value); - } - } - private GroupedFacetResult CreateExpectedFacetResult(string searchTerm, IndexContext context, int offset, int limit, int minCount, bool orderByCount, string facetPrefix) { JCG.Dictionary<string, ISet<string>> facetGroups; @@ -813,7 +784,17 @@ namespace Lucene.Net.Search.Grouping } } - entries.Sort(new ComparerAnonymousHelper2(orderByCount)); + entries.Sort(Comparer<TermGroupFacetCollector.FacetEntry>.Create((a, b) => { + if (orderByCount) + { + int cmp = b.Count - a.Count; + if (cmp != 0) + { + return cmp; + } + } + return a.Value.CompareTo(b.Value); + })); int endOffset = offset + limit; List<TermGroupFacetCollector.FacetEntry> entriesResult; diff --git a/src/Lucene.Net.Tests.Grouping/TestGrouping.cs b/src/Lucene.Net.Tests.Grouping/TestGrouping.cs index bbf320d..282aa51 100644 --- a/src/Lucene.Net.Tests.Grouping/TestGrouping.cs +++ b/src/Lucene.Net.Tests.Grouping/TestGrouping.cs @@ -435,17 +435,10 @@ namespace Lucene.Net.Search.Grouping return new Sort(sortFields.ToArray(/*new SortField[sortFields.size()]*/)); } - internal class ComparerAnonymousHelper : IComparer<GroupDoc> + private IComparer<GroupDoc> GetComparer(Sort sort) { - private readonly TestGrouping outerInstance; - private readonly SortField[] sortFields; - internal ComparerAnonymousHelper(TestGrouping outerInstance, SortField[] sortFields) - { - this.outerInstance = outerInstance; - this.sortFields = sortFields; - } - - public int Compare(GroupDoc d1, GroupDoc d2) + SortField[] sortFields = sort.GetSort(); + return Comparer<GroupDoc>.Create((d1,d2) => { foreach (SortField sf in sortFields) { @@ -486,13 +479,7 @@ namespace Lucene.Net.Search.Grouping // Our sort always fully tie breaks: fail(); return 0; - } - } - - private IComparer<GroupDoc> GetComparer(Sort sort) - { - SortField[] sortFields = sort.GetSort(); - return new ComparerAnonymousHelper(this, sortFields); + }); } private IComparable[] FillFields(GroupDoc d, Sort sort) diff --git a/src/Lucene.Net.Tests.Join/TestJoinUtil.cs b/src/Lucene.Net.Tests.Join/TestJoinUtil.cs index a8bd445..7f7e02a 100644 --- a/src/Lucene.Net.Tests.Join/TestJoinUtil.cs +++ b/src/Lucene.Net.Tests.Join/TestJoinUtil.cs @@ -990,32 +990,10 @@ namespace Lucene.Net.Tests.Join : context.ToHitsToJoinScore[queryValue]; var hits = new List<KeyValuePair<int, JoinScore>>(hitsToJoinScores); - hits.Sort(new ComparerAnonymousInnerClassHelper(this, scoreMode)); - ScoreDoc[] scoreDocs = new ScoreDoc[Math.Min(10, hits.Count)]; - for (int i = 0; i < scoreDocs.Length; i++) + hits.Sort(Comparer< KeyValuePair<int, JoinScore>>.Create( (hit1, hit2) => { - KeyValuePair<int, JoinScore> hit = hits[i]; - scoreDocs[i] = new ScoreDoc(hit.Key, hit.Value.Score(scoreMode)); - } - return new TopDocs(hits.Count, scoreDocs, hits.Count == 0 ? float.NaN : hits[0].Value.Score(scoreMode)); - } - - private class ComparerAnonymousInnerClassHelper : IComparer<KeyValuePair<int, JoinScore>> - { - private readonly TestJoinUtil OuterInstance; - - private ScoreMode ScoreMode; - - public ComparerAnonymousInnerClassHelper(TestJoinUtil outerInstance, ScoreMode scoreMode) - { - OuterInstance = outerInstance; - ScoreMode = scoreMode; - } - - public virtual int Compare(KeyValuePair<int, JoinScore> hit1, KeyValuePair<int, JoinScore> hit2) - { - float score1 = hit1.Value.Score(ScoreMode); - float score2 = hit2.Value.Score(ScoreMode); + float score1 = hit1.Value.Score(scoreMode); + float score2 = hit2.Value.Score(scoreMode); int cmp = score2.CompareTo(score1); if (cmp != 0) @@ -1023,7 +1001,14 @@ namespace Lucene.Net.Tests.Join return cmp; } return hit1.Key - hit2.Key; + })); + ScoreDoc[] scoreDocs = new ScoreDoc[Math.Min(10, hits.Count)]; + for (int i = 0; i < scoreDocs.Length; i++) + { + KeyValuePair<int, JoinScore> hit = hits[i]; + scoreDocs[i] = new ScoreDoc(hit.Key, hit.Value.Score(scoreMode)); } + return new TopDocs(hits.Count, scoreDocs, hits.Count == 0 ? float.NaN : hits[0].Value.Score(scoreMode)); } private FixedBitSet CreateExpectedResult(string queryValue, bool from, IndexReader topLevelReader, diff --git a/src/Lucene.Net.Tests/Index/TestStressIndexing2.cs b/src/Lucene.Net.Tests/Index/TestStressIndexing2.cs index 5e48048..8adb04a 100644 --- a/src/Lucene.Net.Tests/Index/TestStressIndexing2.cs +++ b/src/Lucene.Net.Tests/Index/TestStressIndexing2.cs @@ -152,19 +152,8 @@ namespace Lucene.Net.Index internal static Term IdTerm = new Term("id", ""); internal IndexingThread[] Threads; - internal static IComparer<IIndexableField> fieldNameComparer = new ComparerAnonymousInnerClassHelper(); - private class ComparerAnonymousInnerClassHelper : IComparer<IIndexableField> - { - public ComparerAnonymousInnerClassHelper() - { - } - - public virtual int Compare(IIndexableField o1, IIndexableField o2) - { - return o1.Name.CompareToOrdinal(o2.Name); - } - } + internal static IComparer<IIndexableField> fieldNameComparer = Comparer<IIndexableField>.Create((o1, o2) => o1.Name.CompareToOrdinal(o2.Name)); // this test avoids using any extra synchronization in the multiple // indexing threads to test that IndexWriter does correctly synchronize diff --git a/src/Lucene.Net.Tests/Search/TestQueryRescorer.cs b/src/Lucene.Net.Tests/Search/TestQueryRescorer.cs index 774b7a5..02a41fa 100644 --- a/src/Lucene.Net.Tests/Search/TestQueryRescorer.cs +++ b/src/Lucene.Net.Tests/Search/TestQueryRescorer.cs @@ -393,8 +393,27 @@ namespace Lucene.Net.Search int reverseInt = reverse ? -1 : 1; - Array.Sort(expected, new ComparerAnonymousInnerClassHelper(this, idToNum, r, reverseInt)); - + Array.Sort(expected, + Comparer<int>.Create((a, b) => + { + int av = idToNum[Convert.ToInt32(r.Document(a).Get("id"))]; + int bv = idToNum[Convert.ToInt32(r.Document(b).Get("id"))]; + if (av < bv) + { + return -reverseInt; + } + else if (bv < av) + { + return reverseInt; + } + else + { + // Tie break by docID, ascending + return a - b; + } + }) + ); + bool fail = false; for (int i = 0; i < numHits; i++) { @@ -426,50 +445,7 @@ namespace Lucene.Net.Search return secondPassScore; } } - - private class ComparerAnonymousInnerClassHelper : IComparer<int> - { - private readonly TestQueryRescorer OuterInstance; - - private int[] IdToNum; - private IndexReader r; - private int ReverseInt; - - public ComparerAnonymousInnerClassHelper(TestQueryRescorer outerInstance, int[] idToNum, IndexReader r, int reverseInt) - { - this.OuterInstance = outerInstance; - this.IdToNum = idToNum; - this.r = r; - this.ReverseInt = reverseInt; - } - - public virtual int Compare(int a, int b) - { - try - { - int av = IdToNum[Convert.ToInt32(r.Document(a).Get("id"))]; - int bv = IdToNum[Convert.ToInt32(r.Document(b).Get("id"))]; - if (av < bv) - { - return -ReverseInt; - } - else if (bv < av) - { - return ReverseInt; - } - else - { - // Tie break by docID, ascending - return a - b; - } - } - catch (IOException ioe) - { - throw new Exception(ioe.ToString(), ioe); - } - } - } - + /// <summary> /// Just assigns score == idToNum[doc("id")] for each doc. </summary> private class FixedScoreQuery : Query diff --git a/src/Lucene.Net.Tests/Search/TestSortRandom.cs b/src/Lucene.Net.Tests/Search/TestSortRandom.cs index cea0598..56314a9 100644 --- a/src/Lucene.Net.Tests/Search/TestSortRandom.cs +++ b/src/Lucene.Net.Tests/Search/TestSortRandom.cs @@ -224,7 +224,41 @@ namespace Lucene.Net.Search // Compute expected results: var expected = f.MatchValues.ToList(); - expected.Sort(new ComparerAnonymousInnerClassHelper(this, sortMissingLast)); + + expected.Sort(Comparer<BytesRef>.Create((a,b) => + { + if (a == null) + { + if (b == null) + { + return 0; + } + if (sortMissingLast) + { + return 1; + } + else + { + return -1; + } + } + else if (b == null) + { + if (sortMissingLast) + { + return -1; + } + else + { + return 1; + } + } + else + { + return a.CompareTo(b); + } + })); + if (reverse) { expected.Reverse(); @@ -288,53 +322,6 @@ namespace Lucene.Net.Search dir.Dispose(); } - private class ComparerAnonymousInnerClassHelper : IComparer<BytesRef> - { - private readonly TestSortRandom OuterInstance; - - private bool SortMissingLast; - - public ComparerAnonymousInnerClassHelper(TestSortRandom outerInstance, bool sortMissingLast) - { - this.OuterInstance = outerInstance; - this.SortMissingLast = sortMissingLast; - } - - public virtual int Compare(BytesRef a, BytesRef b) - { - if (a == null) - { - if (b == null) - { - return 0; - } - if (SortMissingLast) - { - return 1; - } - else - { - return -1; - } - } - else if (b == null) - { - if (SortMissingLast) - { - return -1; - } - else - { - return 1; - } - } - else - { - return a.CompareTo(b); - } - } - } - private class RandomFilter : Filter { private readonly Random Random; diff --git a/src/Lucene.Net.Tests/Search/TestSortRescorer.cs b/src/Lucene.Net.Tests/Search/TestSortRescorer.cs index 692f666..2e5532c 100644 --- a/src/Lucene.Net.Tests/Search/TestSortRescorer.cs +++ b/src/Lucene.Net.Tests/Search/TestSortRescorer.cs @@ -169,7 +169,24 @@ namespace Lucene.Net.Search int reverseInt = reverse ? -1 : 1; - Array.Sort(expected, new ComparerAnonymousInnerClassHelper(this, idToNum, r, reverseInt)); + Array.Sort(expected, Comparer<int>.Create((a, b) => + { + int av = idToNum[Convert.ToInt32(r.Document(a).Get("id"))]; + int bv = idToNum[Convert.ToInt32(r.Document(b).Get("id"))]; + if (av < bv) + { + return -reverseInt; + } + else if (bv < av) + { + return reverseInt; + } + else + { + // Tie break by docID, ascending + return a - b; + } + })); bool fail = false; for (int i = 0; i < numHits; i++) @@ -180,49 +197,6 @@ namespace Lucene.Net.Search r.Dispose(); dir.Dispose(); - } - - private class ComparerAnonymousInnerClassHelper : IComparer<int> - { - private readonly TestSortRescorer OuterInstance; - - private int[] IdToNum; - private IndexReader r; - private int ReverseInt; - - public ComparerAnonymousInnerClassHelper(TestSortRescorer outerInstance, int[] idToNum, IndexReader r, int reverseInt) - { - this.OuterInstance = outerInstance; - this.IdToNum = idToNum; - this.r = r; - this.ReverseInt = reverseInt; - } - - public virtual int Compare(int a, int b) - { - try - { - int av = IdToNum[Convert.ToInt32(r.Document(a).Get("id"))]; - int bv = IdToNum[Convert.ToInt32(r.Document(b).Get("id"))]; - if (av < bv) - { - return -ReverseInt; - } - else if (bv < av) - { - return ReverseInt; - } - else - { - // Tie break by docID - return a - b; - } - } - catch (IOException ioe) - { - throw new Exception(ioe.ToString(), ioe); - } - } - } + } } } \ No newline at end of file diff --git a/src/Lucene.Net.Tests/Util/Fst/TestFSTs.cs b/src/Lucene.Net.Tests/Util/Fst/TestFSTs.cs index d61cb59..56bfe33 100644 --- a/src/Lucene.Net.Tests/Util/Fst/TestFSTs.cs +++ b/src/Lucene.Net.Tests/Util/Fst/TestFSTs.cs @@ -1458,20 +1458,8 @@ namespace Lucene.Net.Util.Fst Assert.AreEqual(42, arc.Output); } - internal static readonly IComparer<long?> minLongComparer = new ComparerAnonymousInnerClassHelper(); - - private class ComparerAnonymousInnerClassHelper : IComparer<long?> - { - public ComparerAnonymousInnerClassHelper() - { - } - - public virtual int Compare(long? left, long? right) - { - return left.Value.CompareTo(right.Value); - } - } - + internal static readonly IComparer<long?> minLongComparer = Comparer<long?>.Create((left, right)=> left.Value.CompareTo(right.Value)); + [Test] public virtual void TestShortestPaths() { @@ -1583,20 +1571,8 @@ namespace Lucene.Net.Util.Fst } // compares just the weight side of the pair - internal static readonly IComparer<Pair> minPairWeightComparer = new ComparerAnonymousInnerClassHelper2(); - - private class ComparerAnonymousInnerClassHelper2 : IComparer<Pair> - { - public ComparerAnonymousInnerClassHelper2() - { - } - - public virtual int Compare(Pair left, Pair right) - { - return left.Output1.GetValueOrDefault().CompareTo(right.Output1.GetValueOrDefault()); - } - } - + internal static readonly IComparer<Pair> minPairWeightComparer = Comparer<Pair>.Create((left, right)=> left.Output1.GetValueOrDefault().CompareTo(right.Output1.GetValueOrDefault())); + /// <summary> /// like testShortestPaths, but uses pairoutputs so we have both a weight and an output </summary> [Test] diff --git a/src/Lucene.Net.Tests/Util/TestOfflineSorter.cs b/src/Lucene.Net.Tests/Util/TestOfflineSorter.cs index 798ae3b..5ab155f 100644 --- a/src/Lucene.Net.Tests/Util/TestOfflineSorter.cs +++ b/src/Lucene.Net.Tests/Util/TestOfflineSorter.cs @@ -114,28 +114,19 @@ namespace Lucene.Net.Util return bytes; } - internal static readonly IComparer<byte[]> unsignedByteOrderComparer = new ComparerAnonymousInnerClassHelper(); - - private class ComparerAnonymousInnerClassHelper : IComparer<byte[]> - { - public ComparerAnonymousInnerClassHelper() - { - } - - public virtual int Compare(byte[] left, byte[] right) + internal static readonly IComparer<byte[]> unsignedByteOrderComparer = Comparer<byte[]>.Create((left,right)=> { + int max = Math.Min(left.Length, right.Length); + for (int i = 0, j = 0; i < max; i++, j++) { - int max = Math.Min(left.Length, right.Length); - for (int i = 0, j = 0; i < max; i++, j++) + int diff = (left[i] & 0xff) - (right[j] & 0xff); + if (diff != 0) { - int diff = (left[i] & 0xff) - (right[j] & 0xff); - if (diff != 0) - { - return diff; - } + return diff; } - return left.Length - right.Length; } - } + return left.Length - right.Length; + }); + /// <summary> /// Check sorting data on an instance of <seealso cref="OfflineSorter"/>. /// </summary> diff --git a/src/Lucene.Net/Codecs/Lucene3x/Lucene3xTermVectorsReader.cs b/src/Lucene.Net/Codecs/Lucene3x/Lucene3xTermVectorsReader.cs index e5183dc..f3535d2 100644 --- a/src/Lucene.Net/Codecs/Lucene3x/Lucene3xTermVectorsReader.cs +++ b/src/Lucene.Net/Codecs/Lucene3x/Lucene3xTermVectorsReader.cs @@ -508,25 +508,10 @@ namespace Lucene.Net.Codecs.Lucene3x ReadVectors(); if (unicodeSortOrder) { - Array.Sort(termAndPostings, new ComparerAnonymousInnerClassHelper(this)); + Array.Sort(termAndPostings, Comparer<TermAndPostings>.Create((left, right) => left.Term.CompareTo(right.Term))); } } - - private class ComparerAnonymousInnerClassHelper : IComparer<TermAndPostings> - { - private readonly TVTermsEnum outerInstance; - - public ComparerAnonymousInnerClassHelper(TVTermsEnum outerInstance) - { - this.outerInstance = outerInstance; - } - - public virtual int Compare(TermAndPostings left, TermAndPostings right) - { - return left.Term.CompareTo(right.Term); - } - } - + private void ReadVectors() { termAndPostings = new TermAndPostings[numTerms]; diff --git a/src/Lucene.Net/Index/BufferedUpdatesStream.cs b/src/Lucene.Net/Index/BufferedUpdatesStream.cs index cedb940..4c634ec 100644 --- a/src/Lucene.Net/Index/BufferedUpdatesStream.cs +++ b/src/Lucene.Net/Index/BufferedUpdatesStream.cs @@ -140,15 +140,7 @@ namespace Lucene.Net.Index } // Sorts SegmentInfos from smallest to biggest bufferedDelGen: - private static readonly IComparer<SegmentCommitInfo> sortSegInfoByDelGen = new ComparerAnonymousInnerClassHelper(); - - private class ComparerAnonymousInnerClassHelper : IComparer<SegmentCommitInfo> - { - public ComparerAnonymousInnerClassHelper() - { - } - - public virtual int Compare(SegmentCommitInfo si1, SegmentCommitInfo si2) + private static readonly IComparer<SegmentCommitInfo> sortSegInfoByDelGen = Comparer<SegmentCommitInfo>.Create((si1, si2) => { long cmp = si1.BufferedDeletesGen - si2.BufferedDeletesGen; if (cmp > 0) @@ -163,8 +155,7 @@ namespace Lucene.Net.Index { return 0; } - } - } + }); /// <summary> /// Resolves the buffered deleted Term/Query/docIDs, into diff --git a/src/Lucene.Net/Index/ConcurrentMergeScheduler.cs b/src/Lucene.Net/Index/ConcurrentMergeScheduler.cs index c839f9b..4b9fea2 100644 --- a/src/Lucene.Net/Index/ConcurrentMergeScheduler.cs +++ b/src/Lucene.Net/Index/ConcurrentMergeScheduler.cs @@ -191,15 +191,7 @@ namespace Lucene.Net.Index /// <summary> /// Sorts <see cref="MergeThread"/>s; larger merges come first. </summary> - protected internal static readonly IComparer<MergeThread> compareByMergeDocCount = new ComparerAnonymousInnerClassHelper(); - - private class ComparerAnonymousInnerClassHelper : IComparer<MergeThread> - { - public ComparerAnonymousInnerClassHelper() - { - } - - public virtual int Compare(MergeThread t1, MergeThread t2) + protected internal static readonly IComparer<MergeThread> compareByMergeDocCount = Comparer<MergeThread>.Create((t1, t2) => { MergePolicy.OneMerge m1 = t1.CurrentMerge; MergePolicy.OneMerge m2 = t2.CurrentMerge; @@ -208,8 +200,7 @@ namespace Lucene.Net.Index int c2 = m2 == null ? int.MaxValue : m2.TotalDocCount; return c2 - c1; - } - } + }); /// <summary> /// Called whenever the running merges have changed, to pause & unpause @@ -461,7 +452,7 @@ namespace Lucene.Net.Index } //try //{ - Monitor.Wait(this); + Monitor.Wait(this); //} //catch (ThreadInterruptedException ie) // LUCENENET NOTE: Senseless to catch and rethrow the same exception type //{ @@ -720,13 +711,13 @@ namespace Lucene.Net.Index { //try //{ - // When an exception is hit during merge, IndexWriter - // removes any partial files and then allows another - // merge to run. If whatever caused the error is not - // transient then the exception will keep happening, - // so, we sleep here to avoid saturating CPU in such - // cases: - Thread.Sleep(250); + // When an exception is hit during merge, IndexWriter + // removes any partial files and then allows another + // merge to run. If whatever caused the error is not + // transient then the exception will keep happening, + // so, we sleep here to avoid saturating CPU in such + // cases: + Thread.Sleep(250); //} //catch (ThreadInterruptedException ie) // LUCENENET NOTE: Senseless to catch and rethrow the same exception type //{ diff --git a/src/Lucene.Net/Index/DocFieldProcessor.cs b/src/Lucene.Net/Index/DocFieldProcessor.cs index b38a43c..898776d 100644 --- a/src/Lucene.Net/Index/DocFieldProcessor.cs +++ b/src/Lucene.Net/Index/DocFieldProcessor.cs @@ -284,19 +284,7 @@ namespace Lucene.Net.Index } } - private static readonly IComparer<DocFieldProcessorPerField> fieldsComp = new ComparerAnonymousInnerClassHelper(); - - private class ComparerAnonymousInnerClassHelper : IComparer<DocFieldProcessorPerField> - { - public ComparerAnonymousInnerClassHelper() - { - } - - public virtual int Compare(DocFieldProcessorPerField o1, DocFieldProcessorPerField o2) - { - return o1.fieldInfo.Name.CompareToOrdinal(o2.fieldInfo.Name); - } - } + private static readonly IComparer<DocFieldProcessorPerField> fieldsComp = Comparer<DocFieldProcessorPerField>.Create((o1, o2) => o1.fieldInfo.Name.CompareToOrdinal(o2.fieldInfo.Name)); [MethodImpl(MethodImplOptions.NoInlining)] internal override void FinishDocument() diff --git a/src/Lucene.Net/Search/ConjunctionScorer.cs b/src/Lucene.Net/Search/ConjunctionScorer.cs index ad32d22..ece710f 100644 --- a/src/Lucene.Net/Search/ConjunctionScorer.cs +++ b/src/Lucene.Net/Search/ConjunctionScorer.cs @@ -46,21 +46,7 @@ namespace Lucene.Net.Search } // Sort the array the first time to allow the least frequent DocsEnum to // lead the matching. - ArrayUtil.TimSort(m_docsAndFreqs, new ComparerAnonymousInnerClassHelper(this)); - - lead = m_docsAndFreqs[0]; // least frequent DocsEnum leads the intersection - } - - private class ComparerAnonymousInnerClassHelper : IComparer<DocsAndFreqs> - { - private readonly ConjunctionScorer outerInstance; - - public ComparerAnonymousInnerClassHelper(ConjunctionScorer outerInstance) - { - this.outerInstance = outerInstance; - } - - public virtual int Compare(DocsAndFreqs o1, DocsAndFreqs o2) + ArrayUtil.TimSort(m_docsAndFreqs, Comparer<DocsAndFreqs>.Create((o1, o2) => { if (o1.Cost < o2.Cost) { @@ -74,7 +60,9 @@ namespace Lucene.Net.Search { return 0; } - } + })); + + lead = m_docsAndFreqs[0]; // least frequent DocsEnum leads the intersection } private int DoNext(int doc) diff --git a/src/Lucene.Net/Search/MinShouldMatchSumScorer.cs b/src/Lucene.Net/Search/MinShouldMatchSumScorer.cs index c952bda..847b3ad 100644 --- a/src/Lucene.Net/Search/MinShouldMatchSumScorer.cs +++ b/src/Lucene.Net/Search/MinShouldMatchSumScorer.cs @@ -100,7 +100,7 @@ namespace Lucene.Net.Search this.sortedSubScorers = subScorers.ToArray(); // sorting by decreasing subscorer cost should be inversely correlated with // next docid (assuming costs are due to generating many postings) - ArrayUtil.TimSort(sortedSubScorers, new ComparerAnonymousInnerClassHelper(this)); + ArrayUtil.TimSort(sortedSubScorers, Comparer<Scorer>.Create((o1,o2)=> (o2.GetCost() - o1.GetCost()).Signum())); // take mm-1 most costly subscorers aside this.mmStack = new Scorer[mm - 1]; for (int i = 0; i < mm - 1; i++) @@ -119,21 +119,6 @@ namespace Lucene.Net.Search Debug.Assert(MinheapCheck()); } - private class ComparerAnonymousInnerClassHelper : IComparer<Scorer> - { - private readonly MinShouldMatchSumScorer outerInstance; - - public ComparerAnonymousInnerClassHelper(MinShouldMatchSumScorer outerInstance) - { - this.outerInstance = outerInstance; - } - - public virtual int Compare(Scorer o1, Scorer o2) - { - return (o2.GetCost() - o1.GetCost()).Signum(); - } - } - /// <summary> /// Construct a <see cref="DisjunctionScorer"/>, using one as the minimum number /// of matching <paramref name="subScorers"/>. diff --git a/src/Lucene.Net/Search/QueryRescorer.cs b/src/Lucene.Net/Search/QueryRescorer.cs index 0d64d19..655c326 100644 --- a/src/Lucene.Net/Search/QueryRescorer.cs +++ b/src/Lucene.Net/Search/QueryRescorer.cs @@ -54,7 +54,7 @@ namespace Lucene.Net.Search public override TopDocs Rescore(IndexSearcher searcher, TopDocs firstPassTopDocs, int topN) { ScoreDoc[] hits = (ScoreDoc[])firstPassTopDocs.ScoreDocs.Clone(); - Array.Sort(hits, new ComparerAnonymousInnerClassHelper(this)); + Array.Sort(hits, Comparer<ScoreDoc>.Create((a, b) => a.Doc - b.Doc)); IList<AtomicReaderContext> leaves = searcher.IndexReader.Leaves; @@ -111,43 +111,7 @@ namespace Lucene.Net.Search // TODO: we should do a partial sort (of only topN) // instead, but typically the number of hits is // smallish: - Array.Sort(hits, new ComparerAnonymousInnerClassHelper2(this)); - - if (topN < hits.Length) - { - ScoreDoc[] subset = new ScoreDoc[topN]; - Array.Copy(hits, 0, subset, 0, topN); - hits = subset; - } - - return new TopDocs(firstPassTopDocs.TotalHits, hits, hits[0].Score); - } - - private class ComparerAnonymousInnerClassHelper : IComparer<ScoreDoc> - { - private readonly QueryRescorer outerInstance; - - public ComparerAnonymousInnerClassHelper(QueryRescorer outerInstance) - { - this.outerInstance = outerInstance; - } - - public virtual int Compare(ScoreDoc a, ScoreDoc b) - { - return a.Doc - b.Doc; - } - } - - private class ComparerAnonymousInnerClassHelper2 : IComparer<ScoreDoc> - { - private readonly QueryRescorer outerInstance; - - public ComparerAnonymousInnerClassHelper2(QueryRescorer outerInstance) - { - this.outerInstance = outerInstance; - } - - public virtual int Compare(ScoreDoc a, ScoreDoc b) + Array.Sort(hits, Comparer<ScoreDoc>.Create((a, b) => { // Sort by score descending, then docID ascending: if (a.Score > b.Score) @@ -164,7 +128,16 @@ namespace Lucene.Net.Search // because docIDs are >= 0: return a.Doc - b.Doc; } + })); + + if (topN < hits.Length) + { + ScoreDoc[] subset = new ScoreDoc[topN]; + Array.Copy(hits, 0, subset, 0, topN); + hits = subset; } + + return new TopDocs(firstPassTopDocs.TotalHits, hits, hits[0].Score); } public override Explanation Explain(IndexSearcher searcher, Explanation firstPassExplanation, int docID) diff --git a/src/Lucene.Net/Search/SloppyPhraseScorer.cs b/src/Lucene.Net/Search/SloppyPhraseScorer.cs index b630e61..23773de 100644 --- a/src/Lucene.Net/Search/SloppyPhraseScorer.cs +++ b/src/Lucene.Net/Search/SloppyPhraseScorer.cs @@ -434,7 +434,7 @@ namespace Lucene.Net.Search private void SortRptGroups(IList<IList<PhrasePositions>> rgs) { rptGroups = new PhrasePositions[rgs.Count][]; - IComparer<PhrasePositions> cmprtr = new ComparerAnonymousInnerClassHelper(this); + IComparer<PhrasePositions> cmprtr = Comparer<PhrasePositions>.Create((pp1, pp2) => pp1.offset - pp2.offset); for (int i = 0; i < rptGroups.Length; i++) { PhrasePositions[] rg = rgs[i].ToArray(); @@ -446,22 +446,7 @@ namespace Lucene.Net.Search } } } - - private class ComparerAnonymousInnerClassHelper : IComparer<PhrasePositions> - { - private readonly SloppyPhraseScorer outerInstance; - - public ComparerAnonymousInnerClassHelper(SloppyPhraseScorer outerInstance) - { - this.outerInstance = outerInstance; - } - - public virtual int Compare(PhrasePositions pp1, PhrasePositions pp2) - { - return pp1.offset - pp2.offset; - } - } - + /// <summary> /// Detect repetition groups. Done once - for first doc. </summary> private IList<IList<PhrasePositions>> GatherRptGroups(JCG.LinkedDictionary<Term, int?> rptTerms) diff --git a/src/Lucene.Net/Search/SortRescorer.cs b/src/Lucene.Net/Search/SortRescorer.cs index 0329978..f793730 100644 --- a/src/Lucene.Net/Search/SortRescorer.cs +++ b/src/Lucene.Net/Search/SortRescorer.cs @@ -43,7 +43,7 @@ namespace Lucene.Net.Search { // Copy ScoreDoc[] and sort by ascending docID: ScoreDoc[] hits = (ScoreDoc[])firstPassTopDocs.ScoreDocs.Clone(); - Array.Sort(hits, new ComparerAnonymousInnerClassHelper(this)); + Array.Sort(hits, Comparer<ScoreDoc>.Create((a, b) => a.Doc - b.Doc)); IList<AtomicReaderContext> leaves = searcher.IndexReader.Leaves; @@ -88,21 +88,6 @@ namespace Lucene.Net.Search return collector.GetTopDocs(); } - private class ComparerAnonymousInnerClassHelper : IComparer<ScoreDoc> - { - private readonly SortRescorer outerInstance; - - public ComparerAnonymousInnerClassHelper(SortRescorer outerInstance) - { - this.outerInstance = outerInstance; - } - - public virtual int Compare(ScoreDoc a, ScoreDoc b) - { - return a.Doc - b.Doc; - } - } - public override Explanation Explain(IndexSearcher searcher, Explanation firstPassExplanation, int docID) { TopDocs oneHit = new TopDocs(1, new ScoreDoc[] { new ScoreDoc(docID, firstPassExplanation.Value) }); diff --git a/src/Lucene.Net/Search/TopTermsRewrite.cs b/src/Lucene.Net/Search/TopTermsRewrite.cs index 21f1d26..2f07eb8 100644 --- a/src/Lucene.Net/Search/TopTermsRewrite.cs +++ b/src/Lucene.Net/Search/TopTermsRewrite.cs @@ -244,21 +244,12 @@ namespace Lucene.Net.Search return false; } - private static readonly IComparer<ScoreTerm> scoreTermSortByTermComp = new ComparerAnonymousInnerClassHelper(); - - private class ComparerAnonymousInnerClassHelper : IComparer<ScoreTerm> + private static readonly IComparer<ScoreTerm> scoreTermSortByTermComp = Comparer<ScoreTerm>.Create((st1, st2) => { - public ComparerAnonymousInnerClassHelper() - { - } - - public virtual int Compare(ScoreTerm st1, ScoreTerm st2) - { - Debug.Assert(st1.TermComp == st2.TermComp, "term comparer should not change between segments"); - return st1.TermComp.Compare(st1.Bytes, st2.Bytes); - } - } - + Debug.Assert(st1.TermComp == st2.TermComp, "term comparer should not change between segments"); + return st1.TermComp.Compare(st1.Bytes, st2.Bytes); + }); + internal sealed class ScoreTerm : IComparable<ScoreTerm> { public IComparer<BytesRef> TermComp { get; private set; } diff --git a/src/Lucene.Net/Util/StringHelper.cs b/src/Lucene.Net/Util/StringHelper.cs index b85ed37..e742e1d 100644 --- a/src/Lucene.Net/Util/StringHelper.cs +++ b/src/Lucene.Net/Util/StringHelper.cs @@ -102,52 +102,43 @@ namespace Lucene.Net.Util } } - private static readonly IComparer<string> versionComparer = new ComparerAnonymousInnerClassHelper(); - - private sealed class ComparerAnonymousInnerClassHelper : IComparer<string> + private static readonly IComparer<string> versionComparer = Comparer<string>.Create((a, b) => { - public ComparerAnonymousInnerClassHelper() - { - } + var aTokens = new StringTokenizer(a, "."); + var bTokens = new StringTokenizer(b, "."); - public int Compare(string a, string b) + while (aTokens.MoveNext()) { - var aTokens = new StringTokenizer(a, "."); - var bTokens = new StringTokenizer(b, "."); - - while (aTokens.MoveNext()) + int aToken = Convert.ToInt32(aTokens.Current, CultureInfo.InvariantCulture); + if (bTokens.MoveNext()) { - int aToken = Convert.ToInt32(aTokens.Current, CultureInfo.InvariantCulture); - if (bTokens.MoveNext()) + int bToken = Convert.ToInt32(bTokens.Current, CultureInfo.InvariantCulture); + if (aToken != bToken) { - int bToken = Convert.ToInt32(bTokens.Current, CultureInfo.InvariantCulture); - if (aToken != bToken) - { - return aToken < bToken ? -1 : 1; - } - } - else - { - // a has some extra trailing tokens. if these are all zeroes, thats ok. - if (aToken != 0) - { - return 1; - } + return aToken < bToken ? -1 : 1; } } - - // b has some extra trailing tokens. if these are all zeroes, thats ok. - while (bTokens.MoveNext()) + else { - if (Convert.ToInt32(bTokens.Current, CultureInfo.InvariantCulture) != 0) + // a has some extra trailing tokens. if these are all zeroes, thats ok. + if (aToken != 0) { - return -1; + return 1; } } + } - return 0; + // b has some extra trailing tokens. if these are all zeroes, thats ok. + while (bTokens.MoveNext()) + { + if (Convert.ToInt32(bTokens.Current, CultureInfo.InvariantCulture) != 0) + { + return -1; + } } - } + + return 0; + }); public static bool Equals(string s1, string s2) { diff --git a/src/Lucene.Net/Util/WAH8DocIdSet.cs b/src/Lucene.Net/Util/WAH8DocIdSet.cs index 455c3c0..b5f21fa 100644 --- a/src/Lucene.Net/Util/WAH8DocIdSet.cs +++ b/src/Lucene.Net/Util/WAH8DocIdSet.cs @@ -98,20 +98,8 @@ namespace Lucene.Net.Util return buffer; } - private static readonly IComparer<Iterator> SERIALIZED_LENGTH_COMPARER = new ComparerAnonymousInnerClassHelper(); - - private class ComparerAnonymousInnerClassHelper : IComparer<Iterator> - { - public ComparerAnonymousInnerClassHelper() - { - } - - public virtual int Compare(Iterator wi1, Iterator wi2) - { - return [email protected] - [email protected]; - } - } - + private static readonly IComparer<Iterator> SERIALIZED_LENGTH_COMPARER = Comparer<Iterator>.Create((wi1, wi2) => [email protected] - [email protected]); + /// <summary> /// Same as <see cref="Intersect(ICollection{WAH8DocIdSet}, int)"/> with the default index interval. </summary> public static WAH8DocIdSet Intersect(ICollection<WAH8DocIdSet> docIdSets) @@ -178,7 +166,7 @@ namespace Lucene.Net.Util Debug.Assert(word != 0); builder.AddWord(wordNum, word); ++wordNum; - mainContinue: ; + mainContinue:; } //mainBreak: return builder.Build(); @@ -902,9 +890,9 @@ namespace Lucene.Net.Util /// Return the memory usage of this class in bytes. </summary> public long RamBytesUsed() { - return RamUsageEstimator.AlignObjectSize(3 * RamUsageEstimator.NUM_BYTES_OBJECT_REF + 2 * RamUsageEstimator.NUM_BYTES_INT32) - + RamUsageEstimator.SizeOf(data) - + positions.RamBytesUsed() + return RamUsageEstimator.AlignObjectSize(3 * RamUsageEstimator.NUM_BYTES_OBJECT_REF + 2 * RamUsageEstimator.NUM_BYTES_INT32) + + RamUsageEstimator.SizeOf(data) + + positions.RamBytesUsed() + wordNums.RamBytesUsed(); } }
