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 2020/04/01 15:26:30 UTC
[lucenenet] branch master updated (1274197 -> 5ca25da)
This is an automated email from the ASF dual-hosted git repository.
nightowl888 pushed a change to branch master
in repository https://gitbox.apache.org/repos/asf/lucenenet.git.
from 1274197 Lucene.Net.Store.FSDirectory: Fixed broken XML doc comment
new d90db02 Converted anonymous IComparer<T> classes to use Comparer.Create() delegate method
new bed4c2c renamed start/end to startIndex/length
new 5ca25da azure-pipelines.yml, build.ps1: Updated command to update version numbers from the (no longer supported) vso[task.setvariable variable=Build.BuildNumber] to vso[build.updatebuildnumber] (closes #239)
The 3 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
azure-pipelines.yml | 4 +-
build/build.ps1 | 1 -
.../Analysis/Hunspell/Dictionary.cs | 98 ++++++++----------
.../Analysis/Hunspell/HunspellStemFilter.cs | 25 ++---
.../Analysis/Util/OpenStringBuilder.cs | 18 ++--
.../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 ++---
42 files changed, 438 insertions(+), 985 deletions(-)
[lucenenet] 02/03: renamed start/end to startIndex/length
Posted by ni...@apache.org.
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 bed4c2c633d4b39341104bdb66fdbdeb9612476e
Author: Michael <mi...@bongohr.org>
AuthorDate: Mon Mar 30 15:49:27 2020 +0700
renamed start/end to startIndex/length
Related Work Items: #2
---
.../Analysis/Util/OpenStringBuilder.cs | 18 +++++++++---------
1 file changed, 9 insertions(+), 9 deletions(-)
diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Util/OpenStringBuilder.cs b/src/Lucene.Net.Analysis.Common/Analysis/Util/OpenStringBuilder.cs
index 164b229..0f41a0f 100644
--- a/src/Lucene.Net.Analysis.Common/Analysis/Util/OpenStringBuilder.cs
+++ b/src/Lucene.Net.Analysis.Common/Analysis/Util/OpenStringBuilder.cs
@@ -78,10 +78,10 @@ namespace Lucene.Net.Analysis.Util
return Append(csq, 0, csq.Length);
}
- public virtual OpenStringBuilder Append(ICharSequence csq, int start, int end) // LUCENENET TODO: API - change to startIndex/length to match .NET
+ public virtual OpenStringBuilder Append(ICharSequence csq, int startIndex, int length) // LUCENENET TODO: API - change to startIndex/length to match .NET
{
- EnsureCapacity(end - start);
- for (int i = start; i < end; i++)
+ EnsureCapacity(length - startIndex);
+ for (int i = startIndex; i < length; i++)
{
UnsafeWrite(csq[i]);
}
@@ -95,10 +95,10 @@ namespace Lucene.Net.Analysis.Util
}
// LUCENENET specific - overload for string (more common in .NET than ICharSequence)
- public virtual OpenStringBuilder Append(string csq, int start, int end) // LUCENENET TODO: API - change to startIndex/length to match .NET
+ public virtual OpenStringBuilder Append(string csq, int startIndex, int length) // LUCENENET TODO: API - change to startIndex/length to match .NET
{
- EnsureCapacity(end - start);
- for (int i = start; i < end; i++)
+ EnsureCapacity(length - startIndex);
+ for (int i = startIndex; i < length; i++)
{
UnsafeWrite(csq[i]);
}
@@ -112,10 +112,10 @@ namespace Lucene.Net.Analysis.Util
}
// LUCENENET specific - overload for StringBuilder
- public virtual OpenStringBuilder Append(StringBuilder csq, int start, int end) // LUCENENET TODO: API - change to startIndex/length to match .NET
+ public virtual OpenStringBuilder Append(StringBuilder csq, int startIndex, int length) // LUCENENET TODO: API - change to startIndex/length to match .NET
{
- EnsureCapacity(end - start);
- for (int i = start; i < end; i++)
+ EnsureCapacity(length - startIndex);
+ for (int i = startIndex; i < length; i++)
{
UnsafeWrite(csq[i]);
}
[lucenenet] 03/03: azure-pipelines.yml,
build.ps1: Updated command to update version numbers from the (no
longer supported) vso[task.setvariable variable=Build.BuildNumber] to
vso[build.updatebuildnumber] (closes #239)
Posted by ni...@apache.org.
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 5ca25da899940b00cf7cf7773fe093ababaafc54
Author: bongohrtech <mi...@bongohr.org>
AuthorDate: Thu Mar 26 13:43:31 2020 +0700
azure-pipelines.yml, build.ps1: Updated command to update version numbers from the (no longer supported) vso[task.setvariable variable=Build.BuildNumber] to vso[build.updatebuildnumber] (closes #239)
---
azure-pipelines.yml | 4 ++--
build/build.ps1 | 1 -
2 files changed, 2 insertions(+), 3 deletions(-)
diff --git a/azure-pipelines.yml b/azure-pipelines.yml
index 0ff3508..d3d2b30 100644
--- a/azure-pipelines.yml
+++ b/azure-pipelines.yml
@@ -333,7 +333,7 @@ stages:
- powershell: |
$version = Get-Content '$(Build.ArtifactStagingDirectory)/$(VersionArtifactName)/$(PackageVersionFileName)' -Raw
Write-Host "##vso[task.setvariable variable=PackageVersion;]$version"
- Write-Host "##vso[task.setvariable variable=Build.BuildNumber;]$version"
+ Write-Host "##vso[build.updatebuildnumber]$version"
displayName: 'Read PackageVersion from File to Build.BuildNumber'
- template: 'build/azure-templates/show-all-environment-variables.yml'
@@ -378,7 +378,7 @@ stages:
$vcsLabel = 'Lucene.Net_' + $version.Replace('.', '_').Replace('-', '_')
Write-Host "##vso[task.setvariable variable=VCSLabel;]$vcsLabel"
Write-Host "##vso[task.setvariable variable=PackageVersion;]$version"
- Write-Host "##vso[task.setvariable variable=Build.BuildNumber;]$version"
+ Write-Host "##vso[build.updatebuildnumber]$version"
displayName: 'Build VCS Label and Rehydrate Version Variables'
- powershell: |
diff --git a/build/build.ps1 b/build/build.ps1
index b03631c..176fa2e 100644
--- a/build/build.ps1
+++ b/build/build.ps1
@@ -94,7 +94,6 @@ task Init -depends InstallSDK, UpdateLocalSDKVersion -description "This task mak
#Update TeamCity, MyGet, or Azure Pipelines with packageVersion
Write-Output "##teamcity[buildNumber '$packageVersion']"
Write-Output "##myget[buildNumber '$packageVersion']"
- Write-Host "##vso[task.setvariable variable=Build.BuildNumber;]$packageVersion"
Write-Host "##vso[build.updatebuildnumber]$packageVersion"
& dotnet.exe --version
[lucenenet] 01/03: Converted anonymous IComparer classes to use
Comparer.Create() delegate method
Posted by ni...@apache.org.
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 <mi...@bongohr.org>
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 wi1.@in.Length - wi2.@in.Length;
- }
- }
-
+ private static readonly IComparer<Iterator> SERIALIZED_LENGTH_COMPARER = Comparer<Iterator>.Create((wi1, wi2) => wi1.@in.Length - wi2.@in.Length);
+
/// <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();
}
}