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 2017/02/01 10:21:58 UTC
[01/28] lucenenet git commit: Lucene.Net.Tests.Misc: Added API
consistency tests
Repository: lucenenet
Updated Branches:
refs/heads/api-work ccbf6b10c -> f2e63d354
Lucene.Net.Tests.Misc: Added API consistency tests
Project: http://git-wip-us.apache.org/repos/asf/lucenenet/repo
Commit: http://git-wip-us.apache.org/repos/asf/lucenenet/commit/681a70f7
Tree: http://git-wip-us.apache.org/repos/asf/lucenenet/tree/681a70f7
Diff: http://git-wip-us.apache.org/repos/asf/lucenenet/diff/681a70f7
Branch: refs/heads/api-work
Commit: 681a70f74ce7ca4608dd4f22bfd6e82628311779
Parents: ccbf6b1
Author: Shad Storhaug <sh...@shadstorhaug.com>
Authored: Wed Feb 1 12:49:56 2017 +0700
Committer: Shad Storhaug <sh...@shadstorhaug.com>
Committed: Wed Feb 1 12:49:56 2017 +0700
----------------------------------------------------------------------
.../Lucene.Net.Tests.Misc.csproj | 1 +
src/Lucene.Net.Tests.Misc/TestApiConsistency.cs | 120 +++++++++++++++++++
2 files changed, 121 insertions(+)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/681a70f7/src/Lucene.Net.Tests.Misc/Lucene.Net.Tests.Misc.csproj
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Misc/Lucene.Net.Tests.Misc.csproj b/src/Lucene.Net.Tests.Misc/Lucene.Net.Tests.Misc.csproj
index e086eea..fdbd9a5 100644
--- a/src/Lucene.Net.Tests.Misc/Lucene.Net.Tests.Misc.csproj
+++ b/src/Lucene.Net.Tests.Misc/Lucene.Net.Tests.Misc.csproj
@@ -50,6 +50,7 @@
<Compile Include="Misc\SweetSpotSimilarityTest.cs" />
<Compile Include="Misc\TestHighFreqTerms.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />
+ <Compile Include="TestApiConsistency.cs" />
<Compile Include="Util\Fst\TestFSTsMisc.cs" />
</ItemGroup>
<ItemGroup>
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/681a70f7/src/Lucene.Net.Tests.Misc/TestApiConsistency.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Misc/TestApiConsistency.cs b/src/Lucene.Net.Tests.Misc/TestApiConsistency.cs
new file mode 100644
index 0000000..0ded378
--- /dev/null
+++ b/src/Lucene.Net.Tests.Misc/TestApiConsistency.cs
@@ -0,0 +1,120 @@
+\ufeffusing Lucene.Net.Attributes;
+using Lucene.Net.Util;
+using NUnit.Framework;
+using System;
+
+namespace Lucene.Net.Tests.Misc
+{
+ /// <summary>
+ /// LUCENENET specific tests for ensuring API conventions are followed
+ /// </summary>
+ public class TestApiConsistency : ApiScanTestBase
+ {
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Misc.SweetSpotSimilarity))]
+ public override void TestProtectedFieldNames(Type typeFromTargetAssembly)
+ {
+ base.TestProtectedFieldNames(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Misc.SweetSpotSimilarity))]
+ public override void TestPrivateFieldNames(Type typeFromTargetAssembly)
+ {
+ base.TestPrivateFieldNames(typeFromTargetAssembly, @"Snowball\.Ext\..+Stemmer");
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Misc.SweetSpotSimilarity))]
+ public override void TestPublicFields(Type typeFromTargetAssembly)
+ {
+ base.TestPublicFields(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Misc.SweetSpotSimilarity))]
+ public override void TestMethodParameterNames(Type typeFromTargetAssembly)
+ {
+ base.TestMethodParameterNames(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Misc.SweetSpotSimilarity))]
+ public override void TestInterfaceNames(Type typeFromTargetAssembly)
+ {
+ base.TestInterfaceNames(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Misc.SweetSpotSimilarity))]
+ public override void TestClassNames(Type typeFromTargetAssembly)
+ {
+ base.TestClassNames(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Misc.SweetSpotSimilarity))]
+ public override void TestForPropertiesWithNoGetter(Type typeFromTargetAssembly)
+ {
+ base.TestForPropertiesWithNoGetter(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Misc.SweetSpotSimilarity))]
+ public override void TestForPropertiesThatReturnArray(Type typeFromTargetAssembly)
+ {
+ base.TestForPropertiesThatReturnArray(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Misc.SweetSpotSimilarity))]
+ public override void TestForMethodsThatReturnWritableArray(Type typeFromTargetAssembly)
+ {
+ base.TestForMethodsThatReturnWritableArray(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Misc.SweetSpotSimilarity))]
+ public override void TestForPublicMembersContainingComparer(Type typeFromTargetAssembly)
+ {
+ base.TestForPublicMembersContainingComparer(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Misc.SweetSpotSimilarity))]
+ public override void TestForPublicMembersNamedSize(Type typeFromTargetAssembly)
+ {
+ base.TestForPublicMembersNamedSize(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Misc.SweetSpotSimilarity))]
+ public override void TestForPublicMembersContainingNonNetNumeric(Type typeFromTargetAssembly)
+ {
+ base.TestForPublicMembersContainingNonNetNumeric(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Misc.SweetSpotSimilarity))]
+ public override void TestForPublicMembersWithNullableEnum(Type typeFromTargetAssembly)
+ {
+ base.TestForPublicMembersWithNullableEnum(typeFromTargetAssembly);
+ }
+
+ // LUCENENET NOTE: This test is only for identifying members who were changed from
+ // ICollection, IList or ISet to IEnumerable during the port (that should be changed back)
+ //[Test, LuceneNetSpecific]
+ //[TestCase(typeof(Lucene.Net.Misc.SweetSpotSimilarity))]
+ //public override void TestForMembersAcceptingOrReturningIEnumerable(Type typeFromTargetAssembly)
+ //{
+ // base.TestForMembersAcceptingOrReturningIEnumerable(typeFromTargetAssembly);
+ //}
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Misc.SweetSpotSimilarity))]
+ public override void TestForMembersAcceptingOrReturningListOrDictionary(Type typeFromTargetAssembly)
+ {
+ base.TestForMembersAcceptingOrReturningListOrDictionary(typeFromTargetAssembly);
+ }
+ }
+}
[26/28] lucenenet git commit:
Lucene.Net.Analysis.Stempel.RectangularArrays: changed parameter names to
camelCase
Posted by ni...@apache.org.
Lucene.Net.Analysis.Stempel.RectangularArrays: changed parameter names to camelCase
Project: http://git-wip-us.apache.org/repos/asf/lucenenet/repo
Commit: http://git-wip-us.apache.org/repos/asf/lucenenet/commit/49e5b7a2
Tree: http://git-wip-us.apache.org/repos/asf/lucenenet/tree/49e5b7a2
Diff: http://git-wip-us.apache.org/repos/asf/lucenenet/diff/49e5b7a2
Branch: refs/heads/api-work
Commit: 49e5b7a248096ebfae3fec9f5bd5f8c30920a9fb
Parents: 87f05e9
Author: Shad Storhaug <sh...@shadstorhaug.com>
Authored: Wed Feb 1 17:07:52 2017 +0700
Committer: Shad Storhaug <sh...@shadstorhaug.com>
Committed: Wed Feb 1 17:07:52 2017 +0700
----------------------------------------------------------------------
.../RectangularArrays.cs | 24 ++++++++++----------
1 file changed, 12 insertions(+), 12 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/49e5b7a2/src/Lucene.Net.Analysis.Stempel/RectangularArrays.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Analysis.Stempel/RectangularArrays.cs b/src/Lucene.Net.Analysis.Stempel/RectangularArrays.cs
index 25acdf2..09fe264 100644
--- a/src/Lucene.Net.Analysis.Stempel/RectangularArrays.cs
+++ b/src/Lucene.Net.Analysis.Stempel/RectangularArrays.cs
@@ -10,17 +10,17 @@ using Lucene.Net.Util;
internal static partial class RectangularArrays
{
- internal static int[][] ReturnRectangularIntArray(int Size1, int Size2)
+ internal static int[][] ReturnRectangularIntArray(int size1, int size2)
{
int[][] Array;
- if (Size1 > -1)
+ if (size1 > -1)
{
- Array = new int[Size1][];
- if (Size2 > -1)
+ Array = new int[size1][];
+ if (size2 > -1)
{
- for (int Array1 = 0; Array1 < Size1; Array1++)
+ for (int Array1 = 0; Array1 < size1; Array1++)
{
- Array[Array1] = new int[Size2];
+ Array[Array1] = new int[size2];
}
}
}
@@ -30,17 +30,17 @@ internal static partial class RectangularArrays
return Array;
}
- internal static BytesRef[][] ReturnRectangularBytesRefArray(int Size1, int Size2)
+ internal static BytesRef[][] ReturnRectangularBytesRefArray(int size1, int size2)
{
BytesRef[][] Array;
- if (Size1 > -1)
+ if (size1 > -1)
{
- Array = new BytesRef[Size1][];
- if (Size2 > -1)
+ Array = new BytesRef[size1][];
+ if (size2 > -1)
{
- for (int Array1 = 0; Array1 < Size1; Array1++)
+ for (int Array1 = 0; Array1 < size1; Array1++)
{
- Array[Array1] = new BytesRef[Size2];
+ Array[Array1] = new BytesRef[size2];
}
}
}
[15/28] lucenenet git commit:
Lucene.Net.Grouping.AbstractGroupFacetCollector: changed parameter and return
types from List to IList
Posted by ni...@apache.org.
Lucene.Net.Grouping.AbstractGroupFacetCollector: changed parameter and return types from List<T> to IList<T>
Project: http://git-wip-us.apache.org/repos/asf/lucenenet/repo
Commit: http://git-wip-us.apache.org/repos/asf/lucenenet/commit/885c960b
Tree: http://git-wip-us.apache.org/repos/asf/lucenenet/tree/885c960b
Diff: http://git-wip-us.apache.org/repos/asf/lucenenet/diff/885c960b
Branch: refs/heads/api-work
Commit: 885c960be63a8d65baa352d87b747a3f9d002040
Parents: 8667326
Author: Shad Storhaug <sh...@shadstorhaug.com>
Authored: Wed Feb 1 14:14:54 2017 +0700
Committer: Shad Storhaug <sh...@shadstorhaug.com>
Committed: Wed Feb 1 14:14:54 2017 +0700
----------------------------------------------------------------------
src/Lucene.Net.Grouping/AbstractGroupFacetCollector.cs | 2 +-
src/Lucene.Net.Tests.Grouping/GroupFacetCollectorTest.cs | 8 ++++----
2 files changed, 5 insertions(+), 5 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/885c960b/src/Lucene.Net.Grouping/AbstractGroupFacetCollector.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Grouping/AbstractGroupFacetCollector.cs b/src/Lucene.Net.Grouping/AbstractGroupFacetCollector.cs
index 7cf3222..7e2f6db 100644
--- a/src/Lucene.Net.Grouping/AbstractGroupFacetCollector.cs
+++ b/src/Lucene.Net.Grouping/AbstractGroupFacetCollector.cs
@@ -204,7 +204,7 @@ namespace Lucene.Net.Search.Grouping
/// <param name="offset">The offset in the collected facet entries during merging</param>
/// <param name="limit">The number of facets to return starting from the offset.</param>
/// <returns>a list of facet entries to be rendered based on the specified offset and limit</returns>
- public virtual List<FacetEntry> GetFacetEntries(int offset, int limit)
+ public virtual IList<FacetEntry> GetFacetEntries(int offset, int limit)
{
List<FacetEntry> entries = new List<FacetEntry>();
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/885c960b/src/Lucene.Net.Tests.Grouping/GroupFacetCollectorTest.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Grouping/GroupFacetCollectorTest.cs b/src/Lucene.Net.Tests.Grouping/GroupFacetCollectorTest.cs
index 6e21bd9..a1439d3 100644
--- a/src/Lucene.Net.Tests.Grouping/GroupFacetCollectorTest.cs
+++ b/src/Lucene.Net.Tests.Grouping/GroupFacetCollectorTest.cs
@@ -87,7 +87,7 @@ namespace Lucene.Net.Search.Grouping
IndexSearcher indexSearcher = NewSearcher(w.Reader);
- List<TermGroupFacetCollector.FacetEntry> entries = null;
+ IList<TermGroupFacetCollector.FacetEntry> entries = null;
AbstractGroupFacetCollector groupedAirportFacetCollector = null;
TermGroupFacetCollector.GroupedFacetResult airportResult = null;
@@ -348,7 +348,7 @@ namespace Lucene.Net.Search.Grouping
assertEquals(3, airportResult.TotalCount);
assertEquals(1, airportResult.TotalMissingCount);
- List<TermGroupFacetCollector.FacetEntry> entries = airportResult.GetFacetEntries(0, 10);
+ IList<TermGroupFacetCollector.FacetEntry> entries = airportResult.GetFacetEntries(0, 10);
assertEquals(2, entries.size());
assertEquals("ams", entries[0].Value.Utf8ToString());
assertEquals(2, entries[0].Count);
@@ -423,8 +423,8 @@ namespace Lucene.Net.Search.Grouping
searcher.Search(new TermQuery(new Term("content", searchTerm)), groupFacetCollector);
TermGroupFacetCollector.GroupedFacetResult actualFacetResult = groupFacetCollector.MergeSegmentResults(size, minCount, orderByCount);
- List<TermGroupFacetCollector.FacetEntry> expectedFacetEntries = expectedFacetResult.GetFacetEntries();
- List<TermGroupFacetCollector.FacetEntry> actualFacetEntries = actualFacetResult.GetFacetEntries(offset, limit);
+ IList<TermGroupFacetCollector.FacetEntry> expectedFacetEntries = expectedFacetResult.GetFacetEntries();
+ IList<TermGroupFacetCollector.FacetEntry> actualFacetEntries = actualFacetResult.GetFacetEntries(offset, limit);
if (VERBOSE)
{
[24/28] lucenenet git commit: Lucene.Net.Tests.Analysis.Stempel:
Added API consistency tests
Posted by ni...@apache.org.
Lucene.Net.Tests.Analysis.Stempel: Added API consistency tests
Project: http://git-wip-us.apache.org/repos/asf/lucenenet/repo
Commit: http://git-wip-us.apache.org/repos/asf/lucenenet/commit/2eef6df1
Tree: http://git-wip-us.apache.org/repos/asf/lucenenet/tree/2eef6df1
Diff: http://git-wip-us.apache.org/repos/asf/lucenenet/diff/2eef6df1
Branch: refs/heads/api-work
Commit: 2eef6df1b6dfc5adac38167539cd1aceba00fc01
Parents: c84e63a
Author: Shad Storhaug <sh...@shadstorhaug.com>
Authored: Wed Feb 1 17:04:31 2017 +0700
Committer: Shad Storhaug <sh...@shadstorhaug.com>
Committed: Wed Feb 1 17:04:31 2017 +0700
----------------------------------------------------------------------
.../Lucene.Net.Tests.Analysis.Stempel.csproj | 1 +
.../TestApiConsistency.cs | 120 +++++++++++++++++++
2 files changed, 121 insertions(+)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/2eef6df1/src/Lucene.Net.Tests.Analysis.Stempel/Lucene.Net.Tests.Analysis.Stempel.csproj
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Analysis.Stempel/Lucene.Net.Tests.Analysis.Stempel.csproj b/src/Lucene.Net.Tests.Analysis.Stempel/Lucene.Net.Tests.Analysis.Stempel.csproj
index 93faaa7..9818986 100644
--- a/src/Lucene.Net.Tests.Analysis.Stempel/Lucene.Net.Tests.Analysis.Stempel.csproj
+++ b/src/Lucene.Net.Tests.Analysis.Stempel/Lucene.Net.Tests.Analysis.Stempel.csproj
@@ -45,6 +45,7 @@
<Compile Include="Pl\TestPolishAnalyzer.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />
<Compile Include="Stempel\TestStempelPolishStemFilterFactory.cs" />
+ <Compile Include="TestApiConsistency.cs" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\Lucene.Net.Analysis.Common\Lucene.Net.Analysis.Common.csproj">
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/2eef6df1/src/Lucene.Net.Tests.Analysis.Stempel/TestApiConsistency.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Analysis.Stempel/TestApiConsistency.cs b/src/Lucene.Net.Tests.Analysis.Stempel/TestApiConsistency.cs
new file mode 100644
index 0000000..5d956ee
--- /dev/null
+++ b/src/Lucene.Net.Tests.Analysis.Stempel/TestApiConsistency.cs
@@ -0,0 +1,120 @@
+\ufeffusing Lucene.Net.Attributes;
+using Lucene.Net.Util;
+using NUnit.Framework;
+using System;
+
+namespace Lucene.Net.Analysis.Stempel
+{
+ /// <summary>
+ /// LUCENENET specific tests for ensuring API conventions are followed
+ /// </summary>
+ public class TestApiConsistency : ApiScanTestBase
+ {
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Analysis.Stempel.StempelFilter))]
+ public override void TestProtectedFieldNames(Type typeFromTargetAssembly)
+ {
+ base.TestProtectedFieldNames(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Analysis.Stempel.StempelFilter))]
+ public override void TestPrivateFieldNames(Type typeFromTargetAssembly)
+ {
+ base.TestPrivateFieldNames(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Analysis.Stempel.StempelFilter))]
+ public override void TestPublicFields(Type typeFromTargetAssembly)
+ {
+ base.TestPublicFields(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Analysis.Stempel.StempelFilter))]
+ public override void TestMethodParameterNames(Type typeFromTargetAssembly)
+ {
+ base.TestMethodParameterNames(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Analysis.Stempel.StempelFilter))]
+ public override void TestInterfaceNames(Type typeFromTargetAssembly)
+ {
+ base.TestInterfaceNames(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Analysis.Stempel.StempelFilter))]
+ public override void TestClassNames(Type typeFromTargetAssembly)
+ {
+ base.TestClassNames(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Analysis.Stempel.StempelFilter))]
+ public override void TestForPropertiesWithNoGetter(Type typeFromTargetAssembly)
+ {
+ base.TestForPropertiesWithNoGetter(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Analysis.Stempel.StempelFilter))]
+ public override void TestForPropertiesThatReturnArray(Type typeFromTargetAssembly)
+ {
+ base.TestForPropertiesThatReturnArray(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Analysis.Stempel.StempelFilter))]
+ public override void TestForMethodsThatReturnWritableArray(Type typeFromTargetAssembly)
+ {
+ base.TestForMethodsThatReturnWritableArray(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Analysis.Stempel.StempelFilter))]
+ public override void TestForPublicMembersContainingComparer(Type typeFromTargetAssembly)
+ {
+ base.TestForPublicMembersContainingComparer(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Analysis.Stempel.StempelFilter))]
+ public override void TestForPublicMembersNamedSize(Type typeFromTargetAssembly)
+ {
+ base.TestForPublicMembersNamedSize(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Analysis.Stempel.StempelFilter))]
+ public override void TestForPublicMembersContainingNonNetNumeric(Type typeFromTargetAssembly)
+ {
+ base.TestForPublicMembersContainingNonNetNumeric(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Analysis.Stempel.StempelFilter))]
+ public override void TestForPublicMembersWithNullableEnum(Type typeFromTargetAssembly)
+ {
+ base.TestForPublicMembersWithNullableEnum(typeFromTargetAssembly);
+ }
+
+ // LUCENENET NOTE: This test is only for identifying members who were changed from
+ // ICollection, IList or ISet to IEnumerable during the port (that should be changed back)
+ //[Test, LuceneNetSpecific]
+ //[TestCase(typeof(Lucene.Net.Analysis.Stempel.StempelFilter))]
+ //public override void TestForMembersAcceptingOrReturningIEnumerable(Type typeFromTargetAssembly)
+ //{
+ // base.TestForMembersAcceptingOrReturningIEnumerable(typeFromTargetAssembly);
+ //}
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Analysis.Stempel.StempelFilter))]
+ public override void TestForMembersAcceptingOrReturningListOrDictionary(Type typeFromTargetAssembly)
+ {
+ base.TestForMembersAcceptingOrReturningListOrDictionary(typeFromTargetAssembly);
+ }
+ }
+}
[03/28] lucenenet git commit: Lucene.Net.Misc refactor: made public
fields into properties
Posted by ni...@apache.org.
Lucene.Net.Misc refactor: made public fields into properties
Project: http://git-wip-us.apache.org/repos/asf/lucenenet/repo
Commit: http://git-wip-us.apache.org/repos/asf/lucenenet/commit/81158d88
Tree: http://git-wip-us.apache.org/repos/asf/lucenenet/tree/81158d88
Diff: http://git-wip-us.apache.org/repos/asf/lucenenet/diff/81158d88
Branch: refs/heads/api-work
Commit: 81158d88286ab8f51b55463b50d50f9309605a77
Parents: 754202c
Author: Shad Storhaug <sh...@shadstorhaug.com>
Authored: Wed Feb 1 13:17:05 2017 +0700
Committer: Shad Storhaug <sh...@shadstorhaug.com>
Committed: Wed Feb 1 13:17:05 2017 +0700
----------------------------------------------------------------------
src/Lucene.Net.Misc/Index/IndexSplitter.cs | 28 ++++++++++----------
.../Util/Fst/UpToTwoPositiveIntOutputs.cs | 19 +++++++++----
.../Index/TestIndexSplitter.cs | 2 +-
.../Util/Fst/TestFSTsMisc.cs | 4 +--
4 files changed, 31 insertions(+), 22 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/81158d88/src/Lucene.Net.Misc/Index/IndexSplitter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Misc/Index/IndexSplitter.cs b/src/Lucene.Net.Misc/Index/IndexSplitter.cs
index f0d573f..92b3ba2 100644
--- a/src/Lucene.Net.Misc/Index/IndexSplitter.cs
+++ b/src/Lucene.Net.Misc/Index/IndexSplitter.cs
@@ -43,7 +43,7 @@ namespace Lucene.Net.Index
/// </summary>
public class IndexSplitter
{
- public SegmentInfos infos;
+ public SegmentInfos Infos { get; set; }
internal FSDirectory fsDir;
@@ -93,15 +93,15 @@ namespace Lucene.Net.Index
{
this.dir = dir;
fsDir = FSDirectory.Open(dir);
- infos = new SegmentInfos();
- infos.Read(fsDir);
+ Infos = new SegmentInfos();
+ Infos.Read(fsDir);
}
public virtual void ListSegments()
{
- for (int x = 0; x < infos.Count; x++)
+ for (int x = 0; x < Infos.Count; x++)
{
- SegmentCommitInfo info = infos.Info(x);
+ SegmentCommitInfo info = Infos.Info(x);
string sizeStr = string.Format(CultureInfo.InvariantCulture, "{0:###,###.###}", info.SizeInBytes());
Console.WriteLine(info.Info.Name + " " + sizeStr);
}
@@ -109,9 +109,9 @@ namespace Lucene.Net.Index
private int GetIdx(string name)
{
- for (int x = 0; x < infos.Count; x++)
+ for (int x = 0; x < Infos.Count; x++)
{
- if (name.Equals(infos.Info(x).Info.Name))
+ if (name.Equals(Infos.Info(x).Info.Name))
{
return x;
}
@@ -121,11 +121,11 @@ namespace Lucene.Net.Index
private SegmentCommitInfo GetInfo(string name)
{
- for (int x = 0; x < infos.Count; x++)
+ for (int x = 0; x < Infos.Count; x++)
{
- if (name.Equals(infos.Info(x).Info.Name))
+ if (name.Equals(Infos.Info(x).Info.Name))
{
- return infos.Info(x);
+ return Infos.Info(x);
}
}
return null;
@@ -136,10 +136,10 @@ namespace Lucene.Net.Index
foreach (string n in segs)
{
int idx = GetIdx(n);
- infos.Remove(idx);
+ Infos.Remove(idx);
}
- infos.Changed();
- infos.Commit(fsDir);
+ Infos.Changed();
+ Infos.Commit(fsDir);
}
public virtual void Split(DirectoryInfo destDir, string[] segs)
@@ -147,7 +147,7 @@ namespace Lucene.Net.Index
destDir.Create();
FSDirectory destFSDir = FSDirectory.Open(destDir);
SegmentInfos destInfos = new SegmentInfos();
- destInfos.Counter = infos.Counter;
+ destInfos.Counter = Infos.Counter;
foreach (string n in segs)
{
SegmentCommitInfo infoPerCommit = GetInfo(n);
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/81158d88/src/Lucene.Net.Misc/Util/Fst/UpToTwoPositiveIntOutputs.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Misc/Util/Fst/UpToTwoPositiveIntOutputs.cs b/src/Lucene.Net.Misc/Util/Fst/UpToTwoPositiveIntOutputs.cs
index 21d5fe1..cf3596e 100644
--- a/src/Lucene.Net.Misc/Util/Fst/UpToTwoPositiveIntOutputs.cs
+++ b/src/Lucene.Net.Misc/Util/Fst/UpToTwoPositiveIntOutputs.cs
@@ -54,8 +54,17 @@ namespace Lucene.Net.Util.Fst
/// Holds two long outputs. </summary>
public sealed class TwoLongs
{
- public readonly long first;
- public readonly long second;
+ public long First
+ {
+ get { return first; }
+ }
+ private readonly long first;
+
+ public long Second
+ {
+ get { return second; }
+ }
+ private readonly long second;
public TwoLongs(long first, long second)
{
@@ -196,7 +205,7 @@ namespace Lucene.Net.Util.Fst
{
TwoLongs output = (TwoLongs)_output;
long v = prefix.Value;
- return new TwoLongs(output.first + v, output.second + v);
+ return new TwoLongs(output.First + v, output.Second + v);
}
}
@@ -211,8 +220,8 @@ namespace Lucene.Net.Util.Fst
else
{
TwoLongs output = (TwoLongs)_output;
- @out.WriteVLong((output.first << 1) | 1);
- @out.WriteVLong(output.second);
+ @out.WriteVLong((output.First << 1) | 1);
+ @out.WriteVLong(output.Second);
}
}
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/81158d88/src/Lucene.Net.Tests.Misc/Index/TestIndexSplitter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Misc/Index/TestIndexSplitter.cs b/src/Lucene.Net.Tests.Misc/Index/TestIndexSplitter.cs
index 368c294..6d3d8b3 100644
--- a/src/Lucene.Net.Tests.Misc/Index/TestIndexSplitter.cs
+++ b/src/Lucene.Net.Tests.Misc/Index/TestIndexSplitter.cs
@@ -72,7 +72,7 @@ namespace Lucene.Net.Index
iw.Dispose();
// we should have 2 segments now
IndexSplitter @is = new IndexSplitter(dir);
- string splitSegName = @is.infos.Info(1).Info.Name;
+ string splitSegName = @is.Infos.Info(1).Info.Name;
@is.Split(destDir, new string[] { splitSegName });
Store.Directory fsDirDest = NewFSDirectory(destDir);
DirectoryReader r = DirectoryReader.Open(fsDirDest);
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/81158d88/src/Lucene.Net.Tests.Misc/Util/Fst/TestFSTsMisc.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Misc/Util/Fst/TestFSTsMisc.cs b/src/Lucene.Net.Tests.Misc/Util/Fst/TestFSTsMisc.cs
index a75beaf..41752e0 100644
--- a/src/Lucene.Net.Tests.Misc/Util/Fst/TestFSTsMisc.cs
+++ b/src/Lucene.Net.Tests.Misc/Util/Fst/TestFSTsMisc.cs
@@ -157,13 +157,13 @@ namespace Lucene.Net.Util.Fst
{
UpToTwoPositiveIntOutputs.TwoLongs twoLongs1 = output1 as UpToTwoPositiveIntOutputs.TwoLongs;
long[] list2 = (output2 as IEnumerable<long>).ToArray();
- return (new long[] { twoLongs1.first, twoLongs1.second }).SequenceEqual(list2);
+ return (new long[] { twoLongs1.First, twoLongs1.Second }).SequenceEqual(list2);
}
else if (output2 is UpToTwoPositiveIntOutputs.TwoLongs && output1 is IEnumerable<long>)
{
long[] list1 = (output1 as IEnumerable<long>).ToArray();
UpToTwoPositiveIntOutputs.TwoLongs twoLongs2 = output2 as UpToTwoPositiveIntOutputs.TwoLongs;
- return (new long[] { twoLongs2.first, twoLongs2.second }).SequenceEqual(list1);
+ return (new long[] { twoLongs2.First, twoLongs2.Second }).SequenceEqual(list1);
}
return output1.Equals(output2);
[10/28] lucenenet git commit: Lucene.Net.Tests.Highlighter: added API
consistency tests
Posted by ni...@apache.org.
Lucene.Net.Tests.Highlighter: added API consistency tests
Project: http://git-wip-us.apache.org/repos/asf/lucenenet/repo
Commit: http://git-wip-us.apache.org/repos/asf/lucenenet/commit/fcf634f8
Tree: http://git-wip-us.apache.org/repos/asf/lucenenet/tree/fcf634f8
Diff: http://git-wip-us.apache.org/repos/asf/lucenenet/diff/fcf634f8
Branch: refs/heads/api-work
Commit: fcf634f8073a459039fc9048fbea2e8e0087171b
Parents: 8ddd86b
Author: Shad Storhaug <sh...@shadstorhaug.com>
Authored: Wed Feb 1 13:53:21 2017 +0700
Committer: Shad Storhaug <sh...@shadstorhaug.com>
Committed: Wed Feb 1 13:53:21 2017 +0700
----------------------------------------------------------------------
.../Lucene.Net.Tests.Highlighter.csproj | 1 +
.../TestApiConsistency.cs | 120 +++++++++++++++++++
2 files changed, 121 insertions(+)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/fcf634f8/src/Lucene.Net.Tests.Highlighter/Lucene.Net.Tests.Highlighter.csproj
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Highlighter/Lucene.Net.Tests.Highlighter.csproj b/src/Lucene.Net.Tests.Highlighter/Lucene.Net.Tests.Highlighter.csproj
index 2c4b1ef..e7fc692 100644
--- a/src/Lucene.Net.Tests.Highlighter/Lucene.Net.Tests.Highlighter.csproj
+++ b/src/Lucene.Net.Tests.Highlighter/Lucene.Net.Tests.Highlighter.csproj
@@ -51,6 +51,7 @@
<Compile Include="PostingsHighlight\TestPostingsHighlighterRanking.cs" />
<Compile Include="PostingsHighlight\TestWholeBreakIterator.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />
+ <Compile Include="TestApiConsistency.cs" />
<Compile Include="TestBreakIterator.cs" />
<Compile Include="VectorHighlight\AbstractTestCase.cs" />
<Compile Include="VectorHighlight\BreakIteratorBoundaryScannerTest.cs" />
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/fcf634f8/src/Lucene.Net.Tests.Highlighter/TestApiConsistency.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Highlighter/TestApiConsistency.cs b/src/Lucene.Net.Tests.Highlighter/TestApiConsistency.cs
new file mode 100644
index 0000000..600f5af
--- /dev/null
+++ b/src/Lucene.Net.Tests.Highlighter/TestApiConsistency.cs
@@ -0,0 +1,120 @@
+\ufeffusing Lucene.Net.Attributes;
+using Lucene.Net.Util;
+using NUnit.Framework;
+using System;
+
+namespace Lucene.Net.Search
+{
+ /// <summary>
+ /// LUCENENET specific tests for ensuring API conventions are followed
+ /// </summary>
+ public class TestApiConsistency : ApiScanTestBase
+ {
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Search.Highlight.DefaultEncoder))]
+ public override void TestProtectedFieldNames(Type typeFromTargetAssembly)
+ {
+ base.TestProtectedFieldNames(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Search.Highlight.DefaultEncoder))]
+ public override void TestPrivateFieldNames(Type typeFromTargetAssembly)
+ {
+ base.TestPrivateFieldNames(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Search.Highlight.DefaultEncoder))]
+ public override void TestPublicFields(Type typeFromTargetAssembly)
+ {
+ base.TestPublicFields(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Search.Highlight.DefaultEncoder))]
+ public override void TestMethodParameterNames(Type typeFromTargetAssembly)
+ {
+ base.TestMethodParameterNames(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Search.Highlight.DefaultEncoder))]
+ public override void TestInterfaceNames(Type typeFromTargetAssembly)
+ {
+ base.TestInterfaceNames(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Search.Highlight.DefaultEncoder))]
+ public override void TestClassNames(Type typeFromTargetAssembly)
+ {
+ base.TestClassNames(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Search.Highlight.DefaultEncoder))]
+ public override void TestForPropertiesWithNoGetter(Type typeFromTargetAssembly)
+ {
+ base.TestForPropertiesWithNoGetter(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Search.Highlight.DefaultEncoder))]
+ public override void TestForPropertiesThatReturnArray(Type typeFromTargetAssembly)
+ {
+ base.TestForPropertiesThatReturnArray(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Search.Highlight.DefaultEncoder))]
+ public override void TestForMethodsThatReturnWritableArray(Type typeFromTargetAssembly)
+ {
+ base.TestForMethodsThatReturnWritableArray(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Search.Highlight.DefaultEncoder))]
+ public override void TestForPublicMembersContainingComparer(Type typeFromTargetAssembly)
+ {
+ base.TestForPublicMembersContainingComparer(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Search.Highlight.DefaultEncoder))]
+ public override void TestForPublicMembersNamedSize(Type typeFromTargetAssembly)
+ {
+ base.TestForPublicMembersNamedSize(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Search.Highlight.DefaultEncoder))]
+ public override void TestForPublicMembersContainingNonNetNumeric(Type typeFromTargetAssembly)
+ {
+ base.TestForPublicMembersContainingNonNetNumeric(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Search.Highlight.DefaultEncoder))]
+ public override void TestForPublicMembersWithNullableEnum(Type typeFromTargetAssembly)
+ {
+ base.TestForPublicMembersWithNullableEnum(typeFromTargetAssembly);
+ }
+
+ // LUCENENET NOTE: This test is only for identifying members who were changed from
+ // ICollection, IList or ISet to IEnumerable during the port (that should be changed back)
+ //[Test, LuceneNetSpecific]
+ //[TestCase(typeof(Lucene.Net.Search.Highlight.DefaultEncoder))]
+ //public override void TestForMembersAcceptingOrReturningIEnumerable(Type typeFromTargetAssembly)
+ //{
+ // base.TestForMembersAcceptingOrReturningIEnumerable(typeFromTargetAssembly);
+ //}
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Search.Highlight.DefaultEncoder))]
+ public override void TestForMembersAcceptingOrReturningListOrDictionary(Type typeFromTargetAssembly)
+ {
+ base.TestForMembersAcceptingOrReturningListOrDictionary(typeFromTargetAssembly);
+ }
+ }
+}
[16/28] lucenenet git commit: Lucene.Net.Grouping refactor: renamed
all protected fields camelCase prefixed with m_
Posted by ni...@apache.org.
Lucene.Net.Grouping refactor: renamed all protected fields camelCase prefixed with m_
Project: http://git-wip-us.apache.org/repos/asf/lucenenet/repo
Commit: http://git-wip-us.apache.org/repos/asf/lucenenet/commit/d604cab9
Tree: http://git-wip-us.apache.org/repos/asf/lucenenet/tree/d604cab9
Diff: http://git-wip-us.apache.org/repos/asf/lucenenet/diff/d604cab9
Branch: refs/heads/api-work
Commit: d604cab9c30fdc19549101a1b1fe485872525cc7
Parents: 885c960
Author: Shad Storhaug <sh...@shadstorhaug.com>
Authored: Wed Feb 1 14:20:57 2017 +0700
Committer: Shad Storhaug <sh...@shadstorhaug.com>
Committed: Wed Feb 1 14:20:57 2017 +0700
----------------------------------------------------------------------
.../AbstractAllGroupHeadsCollector.cs | 20 ++--
.../AbstractFirstPassGroupingCollector.cs | 48 ++++-----
.../AbstractGroupFacetCollector.cs | 70 ++++++-------
.../AbstractSecondPassGroupingCollector.cs | 14 +--
.../Function/FunctionAllGroupHeadsCollector.cs | 8 +-
.../FunctionSecondPassGroupingCollector.cs | 2 +-
.../Term/TermAllGroupHeadsCollector.cs | 32 +++---
.../Term/TermGroupFacetCollector.cs | 102 +++++++++----------
.../Term/TermSecondPassGroupingCollector.cs | 10 +-
9 files changed, 153 insertions(+), 153 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/d604cab9/src/Lucene.Net.Grouping/AbstractAllGroupHeadsCollector.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Grouping/AbstractAllGroupHeadsCollector.cs b/src/Lucene.Net.Grouping/AbstractAllGroupHeadsCollector.cs
index fb2983e..f5f5ad0 100644
--- a/src/Lucene.Net.Grouping/AbstractAllGroupHeadsCollector.cs
+++ b/src/Lucene.Net.Grouping/AbstractAllGroupHeadsCollector.cs
@@ -30,15 +30,15 @@ namespace Lucene.Net.Search.Grouping
public abstract class AbstractAllGroupHeadsCollector<GH> : AbstractAllGroupHeadsCollector
where GH : AbstractAllGroupHeadsCollector_GroupHead
{
- protected readonly int[] reversed;
- protected readonly int compIDXEnd;
- protected readonly TemporalResult temporalResult;
+ protected readonly int[] m_reversed;
+ protected readonly int m_compIDXEnd;
+ protected readonly TemporalResult m_temporalResult;
protected AbstractAllGroupHeadsCollector(int numberOfSorts)
{
- this.reversed = new int[numberOfSorts];
- this.compIDXEnd = numberOfSorts - 1;
- temporalResult = new TemporalResult();
+ this.m_reversed = new int[numberOfSorts];
+ this.m_compIDXEnd = numberOfSorts - 1;
+ m_temporalResult = new TemporalResult();
}
/// <summary>
@@ -111,16 +111,16 @@ namespace Lucene.Net.Search.Grouping
public override void Collect(int doc)
{
RetrieveGroupHeadAndAddIfNotExist(doc);
- if (temporalResult.stop)
+ if (m_temporalResult.stop)
{
return;
}
- GH groupHead = temporalResult.groupHead;
+ GH groupHead = m_temporalResult.groupHead;
// Ok now we need to check if the current doc is more relevant then current doc for this group
for (int compIDX = 0; ; compIDX++)
{
- int c = reversed[compIDX] * groupHead.Compare(compIDX, doc);
+ int c = m_reversed[compIDX] * groupHead.Compare(compIDX, doc);
if (c < 0)
{
// Definitely not competitive. So don't even bother to continue
@@ -131,7 +131,7 @@ namespace Lucene.Net.Search.Grouping
// Definitely competitive.
break;
}
- else if (compIDX == compIDXEnd)
+ else if (compIDX == m_compIDXEnd)
{
// Here c=0. If we're at the last comparer, this doc is not
// competitive, since docs are visited in doc Id order, which means
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/d604cab9/src/Lucene.Net.Grouping/AbstractFirstPassGroupingCollector.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Grouping/AbstractFirstPassGroupingCollector.cs b/src/Lucene.Net.Grouping/AbstractFirstPassGroupingCollector.cs
index 750177d..f4bc5fd 100644
--- a/src/Lucene.Net.Grouping/AbstractFirstPassGroupingCollector.cs
+++ b/src/Lucene.Net.Grouping/AbstractFirstPassGroupingCollector.cs
@@ -48,7 +48,7 @@ namespace Lucene.Net.Search.Grouping
// Set once we reach topNGroups unique groups:
// @lucene.internal
- protected SortedSet<CollectedSearchGroup<TGroupValue>> orderedGroups;
+ protected SortedSet<CollectedSearchGroup<TGroupValue>> m_orderedGroups;
private int docBase;
private int spareSlot;
@@ -118,7 +118,7 @@ namespace Lucene.Net.Search.Grouping
return null;
}
- if (orderedGroups == null)
+ if (m_orderedGroups == null)
{
BuildSortedSet();
}
@@ -126,7 +126,7 @@ namespace Lucene.Net.Search.Grouping
ICollection<ISearchGroup<TGroupValue>> result = new List<ISearchGroup<TGroupValue>>();
int upto = 0;
int sortFieldCount = groupSort.GetSort().Length;
- foreach (CollectedSearchGroup<TGroupValue> group in orderedGroups)
+ foreach (CollectedSearchGroup<TGroupValue> group in m_orderedGroups)
{
if (upto++ < groupOffset)
{
@@ -170,7 +170,7 @@ namespace Lucene.Net.Search.Grouping
// Downside: if the number of unique groups is very low, this is
// wasted effort as we will most likely be updating an existing group.
- if (orderedGroups != null)
+ if (m_orderedGroups != null)
{
for (int compIDX = 0; ; compIDX++)
{
@@ -241,12 +241,12 @@ namespace Lucene.Net.Search.Grouping
// the bottom group with this new group.
//CollectedSearchGroup<TGroupValue> bottomGroup = orderedGroups.PollLast();
CollectedSearchGroup<TGroupValue> bottomGroup;
- lock (orderedGroups)
+ lock (m_orderedGroups)
{
- bottomGroup = orderedGroups.Last();
- orderedGroups.Remove(bottomGroup);
+ bottomGroup = m_orderedGroups.Last();
+ m_orderedGroups.Remove(bottomGroup);
}
- Debug.Assert(orderedGroups.Count == topNGroups - 1);
+ Debug.Assert(m_orderedGroups.Count == topNGroups - 1);
groupMap.Remove(bottomGroup.GroupValue);
@@ -260,10 +260,10 @@ namespace Lucene.Net.Search.Grouping
}
groupMap[bottomGroup.GroupValue] = bottomGroup;
- orderedGroups.Add(bottomGroup);
- Debug.Assert(orderedGroups.Count == topNGroups);
+ m_orderedGroups.Add(bottomGroup);
+ Debug.Assert(m_orderedGroups.Count == topNGroups);
- int lastComparerSlot = orderedGroups.Last().ComparerSlot;
+ int lastComparerSlot = m_orderedGroups.Last().ComparerSlot;
foreach (FieldComparer fc in comparers)
{
fc.SetBottom(lastComparerSlot);
@@ -306,14 +306,14 @@ namespace Lucene.Net.Search.Grouping
// TODO: optimize this
CollectedSearchGroup<TGroupValue> prevLast;
- if (orderedGroups != null)
+ if (m_orderedGroups != null)
{
- lock (orderedGroups)
+ lock (m_orderedGroups)
{
- prevLast = orderedGroups.Last();
- orderedGroups.Remove(group);
+ prevLast = m_orderedGroups.Last();
+ m_orderedGroups.Remove(group);
}
- Debug.Assert(orderedGroups.Count == topNGroups - 1);
+ Debug.Assert(m_orderedGroups.Count == topNGroups - 1);
}
else
{
@@ -328,11 +328,11 @@ namespace Lucene.Net.Search.Grouping
group.ComparerSlot = tmp;
// Re-add the changed group
- if (orderedGroups != null)
+ if (m_orderedGroups != null)
{
- orderedGroups.Add(group);
- Debug.Assert(orderedGroups.Count == topNGroups);
- var newLast = orderedGroups.Last();
+ m_orderedGroups.Add(group);
+ Debug.Assert(m_orderedGroups.Count == topNGroups);
+ var newLast = m_orderedGroups.Last();
// If we changed the value of the last group, or changed which group was last, then update bottom:
if (group == newLast || prevLast != newLast)
{
@@ -372,13 +372,13 @@ namespace Lucene.Net.Search.Grouping
private void BuildSortedSet()
{
var comparer = new BuildSortedSetComparer(this);
- orderedGroups = new SortedSet<CollectedSearchGroup<TGroupValue>>(comparer);
- orderedGroups.UnionWith(groupMap.Values);
- Debug.Assert(orderedGroups.Count > 0);
+ m_orderedGroups = new SortedSet<CollectedSearchGroup<TGroupValue>>(comparer);
+ m_orderedGroups.UnionWith(groupMap.Values);
+ Debug.Assert(m_orderedGroups.Count > 0);
foreach (FieldComparer fc in comparers)
{
- fc.SetBottom(orderedGroups.Last().ComparerSlot);
+ fc.SetBottom(m_orderedGroups.Last().ComparerSlot);
}
}
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/d604cab9/src/Lucene.Net.Grouping/AbstractGroupFacetCollector.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Grouping/AbstractGroupFacetCollector.cs b/src/Lucene.Net.Grouping/AbstractGroupFacetCollector.cs
index 7e2f6db..4ccca43 100644
--- a/src/Lucene.Net.Grouping/AbstractGroupFacetCollector.cs
+++ b/src/Lucene.Net.Grouping/AbstractGroupFacetCollector.cs
@@ -28,22 +28,22 @@ namespace Lucene.Net.Search.Grouping
/// </summary>
public abstract class AbstractGroupFacetCollector : ICollector
{
- protected readonly string groupField;
- protected readonly string facetField;
- protected readonly BytesRef facetPrefix;
- protected readonly IList<AbstractSegmentResult> segmentResults;
+ protected readonly string m_groupField;
+ protected readonly string m_facetField;
+ protected readonly BytesRef m_facetPrefix;
+ protected readonly IList<AbstractSegmentResult> m_segmentResults;
- protected int[] segmentFacetCounts;
- protected int segmentTotalCount;
- protected int startFacetOrd;
- protected int endFacetOrd;
+ protected int[] m_segmentFacetCounts;
+ protected int m_segmentTotalCount;
+ protected int m_startFacetOrd;
+ protected int m_endFacetOrd;
protected AbstractGroupFacetCollector(string groupField, string facetField, BytesRef facetPrefix)
{
- this.groupField = groupField;
- this.facetField = facetField;
- this.facetPrefix = facetPrefix;
- segmentResults = new List<AbstractSegmentResult>();
+ this.m_groupField = groupField;
+ this.m_facetField = facetField;
+ this.m_facetPrefix = facetPrefix;
+ m_segmentResults = new List<AbstractSegmentResult>();
}
/// <summary>
@@ -60,23 +60,23 @@ namespace Lucene.Net.Search.Grouping
/// <exception cref="IOException">If I/O related errors occur during merging segment grouped facet counts.</exception>
public virtual GroupedFacetResult MergeSegmentResults(int size, int minCount, bool orderByCount)
{
- if (segmentFacetCounts != null)
+ if (m_segmentFacetCounts != null)
{
- segmentResults.Add(CreateSegmentResult());
- segmentFacetCounts = null; // reset
+ m_segmentResults.Add(CreateSegmentResult());
+ m_segmentFacetCounts = null; // reset
}
int totalCount = 0;
int missingCount = 0;
- SegmentResultPriorityQueue segments = new SegmentResultPriorityQueue(segmentResults.Count);
- foreach (AbstractSegmentResult segmentResult in segmentResults)
+ SegmentResultPriorityQueue segments = new SegmentResultPriorityQueue(m_segmentResults.Count);
+ foreach (AbstractSegmentResult segmentResult in m_segmentResults)
{
- missingCount += segmentResult.missing;
- if (segmentResult.mergePos >= segmentResult.maxTermPos)
+ missingCount += segmentResult.m_missing;
+ if (segmentResult.m_mergePos >= segmentResult.m_maxTermPos)
{
continue;
}
- totalCount += segmentResult.total;
+ totalCount += segmentResult.m_total;
segments.Add(segmentResult);
}
@@ -84,13 +84,13 @@ namespace Lucene.Net.Search.Grouping
while (segments.Count > 0)
{
AbstractSegmentResult segmentResult = segments.Top;
- BytesRef currentFacetValue = BytesRef.DeepCopyOf(segmentResult.mergeTerm);
+ BytesRef currentFacetValue = BytesRef.DeepCopyOf(segmentResult.m_mergeTerm);
int count = 0;
do
{
- count += segmentResult.counts[segmentResult.mergePos++];
- if (segmentResult.mergePos < segmentResult.maxTermPos)
+ count += segmentResult.m_counts[segmentResult.m_mergePos++];
+ if (segmentResult.m_mergePos < segmentResult.m_maxTermPos)
{
segmentResult.NextTerm();
segmentResult = segments.UpdateTop();
@@ -104,7 +104,7 @@ namespace Lucene.Net.Search.Grouping
break;
}
}
- } while (currentFacetValue.Equals(segmentResult.mergeTerm));
+ } while (currentFacetValue.Equals(segmentResult.m_mergeTerm));
facetResult.AddFacetCount(currentFacetValue, count);
}
return facetResult;
@@ -325,20 +325,20 @@ namespace Lucene.Net.Search.Grouping
/// </remarks>
protected internal abstract class AbstractSegmentResult
{
- protected internal readonly int[] counts;
- protected internal readonly int total;
- protected internal readonly int missing;
- protected internal readonly int maxTermPos;
+ protected internal readonly int[] m_counts;
+ protected internal readonly int m_total;
+ protected internal readonly int m_missing;
+ protected internal readonly int m_maxTermPos;
- protected internal BytesRef mergeTerm;
- protected internal int mergePos;
+ protected internal BytesRef m_mergeTerm;
+ protected internal int m_mergePos;
protected AbstractSegmentResult(int[] counts, int total, int missing, int maxTermPos)
{
- this.counts = counts;
- this.total = total;
- this.missing = missing;
- this.maxTermPos = maxTermPos;
+ this.m_counts = counts;
+ this.m_total = total;
+ this.m_missing = missing;
+ this.m_maxTermPos = maxTermPos;
}
/// <summary>
@@ -358,7 +358,7 @@ namespace Lucene.Net.Search.Grouping
protected override bool LessThan(AbstractSegmentResult a, AbstractSegmentResult b)
{
- return a.mergeTerm.CompareTo(b.mergeTerm) < 0;
+ return a.m_mergeTerm.CompareTo(b.m_mergeTerm) < 0;
}
}
}
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/d604cab9/src/Lucene.Net.Grouping/AbstractSecondPassGroupingCollector.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Grouping/AbstractSecondPassGroupingCollector.cs b/src/Lucene.Net.Grouping/AbstractSecondPassGroupingCollector.cs
index 93b6cd0..deb44a3 100644
--- a/src/Lucene.Net.Grouping/AbstractSecondPassGroupingCollector.cs
+++ b/src/Lucene.Net.Grouping/AbstractSecondPassGroupingCollector.cs
@@ -38,9 +38,9 @@ namespace Lucene.Net.Search.Grouping
/// <typeparam name="TGroupValue"></typeparam>
public abstract class AbstractSecondPassGroupingCollector<TGroupValue> : IAbstractSecondPassGroupingCollector<TGroupValue>
{
- protected readonly IDictionary<TGroupValue, AbstractSecondPassGroupingCollector.SearchGroupDocs<TGroupValue>> groupMap;
+ protected readonly IDictionary<TGroupValue, AbstractSecondPassGroupingCollector.SearchGroupDocs<TGroupValue>> m_groupMap;
private readonly int maxDocsPerGroup;
- protected AbstractSecondPassGroupingCollector.SearchGroupDocs<TGroupValue>[] groupDocs;
+ protected AbstractSecondPassGroupingCollector.SearchGroupDocs<TGroupValue>[] m_groupDocs;
private readonly IEnumerable<ISearchGroup<TGroupValue>> groups;
private readonly Sort withinGroupSort;
private readonly Sort groupSort;
@@ -62,7 +62,7 @@ namespace Lucene.Net.Search.Grouping
this.withinGroupSort = withinGroupSort;
this.groups = groups;
this.maxDocsPerGroup = maxDocsPerGroup;
- groupMap = new HashMap<TGroupValue, AbstractSecondPassGroupingCollector.SearchGroupDocs<TGroupValue>>(groups.Count());
+ m_groupMap = new HashMap<TGroupValue, AbstractSecondPassGroupingCollector.SearchGroupDocs<TGroupValue>>(groups.Count());
foreach (SearchGroup<TGroupValue> group in groups)
{
@@ -78,13 +78,13 @@ namespace Lucene.Net.Search.Grouping
// Sort by fields
collector = TopFieldCollector.Create(withinGroupSort, maxDocsPerGroup, fillSortFields, getScores, getMaxScores, true);
}
- groupMap[group.GroupValue] = new AbstractSecondPassGroupingCollector.SearchGroupDocs<TGroupValue>(group.GroupValue, collector);
+ m_groupMap[group.GroupValue] = new AbstractSecondPassGroupingCollector.SearchGroupDocs<TGroupValue>(group.GroupValue, collector);
}
}
public virtual void SetScorer(Scorer scorer)
{
- foreach (AbstractSecondPassGroupingCollector.SearchGroupDocs<TGroupValue> group in groupMap.Values)
+ foreach (AbstractSecondPassGroupingCollector.SearchGroupDocs<TGroupValue> group in m_groupMap.Values)
{
group.collector.SetScorer(scorer);
}
@@ -112,7 +112,7 @@ namespace Lucene.Net.Search.Grouping
public virtual void SetNextReader(AtomicReaderContext context)
{
//System.out.println("SP.setNextReader");
- foreach (AbstractSecondPassGroupingCollector.SearchGroupDocs<TGroupValue> group in groupMap.Values)
+ foreach (AbstractSecondPassGroupingCollector.SearchGroupDocs<TGroupValue> group in m_groupMap.Values)
{
group.collector.SetNextReader(context);
}
@@ -131,7 +131,7 @@ namespace Lucene.Net.Search.Grouping
float maxScore = float.MinValue;
foreach (var group in groups)
{
- AbstractSecondPassGroupingCollector.SearchGroupDocs<TGroupValue> groupDocs = groupMap.ContainsKey(group.GroupValue) ? groupMap[group.GroupValue] : null;
+ AbstractSecondPassGroupingCollector.SearchGroupDocs<TGroupValue> groupDocs = m_groupMap.ContainsKey(group.GroupValue) ? m_groupMap[group.GroupValue] : null;
TopDocs topDocs = groupDocs.collector.GetTopDocs(withinGroupOffset, maxDocsPerGroup);
groupDocsResult[groupIDX++] = new GroupDocs<TGroupValue>(float.NaN,
topDocs.MaxScore,
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/d604cab9/src/Lucene.Net.Grouping/Function/FunctionAllGroupHeadsCollector.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Grouping/Function/FunctionAllGroupHeadsCollector.cs b/src/Lucene.Net.Grouping/Function/FunctionAllGroupHeadsCollector.cs
index 5c6804b..6ca3cdf 100644
--- a/src/Lucene.Net.Grouping/Function/FunctionAllGroupHeadsCollector.cs
+++ b/src/Lucene.Net.Grouping/Function/FunctionAllGroupHeadsCollector.cs
@@ -58,7 +58,7 @@ namespace Lucene.Net.Search.Grouping.Function
SortField[] sortFields = sortWithinGroup.GetSort();
for (int i = 0; i < sortFields.Length; i++)
{
- reversed[i] = sortFields[i].IsReverse ? -1 : 1;
+ m_reversed[i] = sortFields[i].IsReverse ? -1 : 1;
}
}
@@ -71,13 +71,13 @@ namespace Lucene.Net.Search.Grouping.Function
MutableValue groupValue = mval.Duplicate();
groupHead = new GroupHead(this, groupValue, sortWithinGroup, doc);
groups[groupValue] = groupHead;
- temporalResult.stop = true;
+ m_temporalResult.stop = true;
}
else
{
- temporalResult.stop = false;
+ m_temporalResult.stop = false;
}
- this.temporalResult.groupHead = groupHead;
+ this.m_temporalResult.groupHead = groupHead;
}
protected override ICollection<GroupHead> CollectedGroupHeads
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/d604cab9/src/Lucene.Net.Grouping/Function/FunctionSecondPassGroupingCollector.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Grouping/Function/FunctionSecondPassGroupingCollector.cs b/src/Lucene.Net.Grouping/Function/FunctionSecondPassGroupingCollector.cs
index b4982ae..75222e6 100644
--- a/src/Lucene.Net.Grouping/Function/FunctionSecondPassGroupingCollector.cs
+++ b/src/Lucene.Net.Grouping/Function/FunctionSecondPassGroupingCollector.cs
@@ -63,7 +63,7 @@ namespace Lucene.Net.Search.Grouping.Function
{
filler.FillValue(doc);
AbstractSecondPassGroupingCollector.SearchGroupDocs<MutableValue> result;
- groupMap.TryGetValue(mval, out result);
+ m_groupMap.TryGetValue(mval, out result);
return result;
}
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/d604cab9/src/Lucene.Net.Grouping/Term/TermAllGroupHeadsCollector.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Grouping/Term/TermAllGroupHeadsCollector.cs b/src/Lucene.Net.Grouping/Term/TermAllGroupHeadsCollector.cs
index 20b6f7e..88ab3ce 100644
--- a/src/Lucene.Net.Grouping/Term/TermAllGroupHeadsCollector.cs
+++ b/src/Lucene.Net.Grouping/Term/TermAllGroupHeadsCollector.cs
@@ -154,7 +154,7 @@ namespace Lucene.Net.Search.Grouping.Terms
SortField[] sortFields = sortWithinGroup.GetSort();
for (int i = 0; i < sortFields.Length; i++)
{
- reversed[i] = sortFields[i].IsReverse ? -1 : 1;
+ m_reversed[i] = sortFields[i].IsReverse ? -1 : 1;
}
}
@@ -176,13 +176,13 @@ namespace Lucene.Net.Search.Grouping.Terms
{
groupHead = new GroupHead(this, groupValue, sortWithinGroup, doc);
groups[groupValue == null ? null : BytesRef.DeepCopyOf(groupValue)] = groupHead;
- temporalResult.stop = true;
+ m_temporalResult.stop = true;
}
else
{
- temporalResult.stop = false;
+ m_temporalResult.stop = false;
}
- temporalResult.groupHead = groupHead;
+ m_temporalResult.groupHead = groupHead;
}
protected override ICollection<GroupHead> CollectedGroupHeads
@@ -284,7 +284,7 @@ namespace Lucene.Net.Search.Grouping.Terms
sortsIndex = new SortedDocValues[sortFields.Length];
for (int i = 0; i < sortFields.Length; i++)
{
- reversed[i] = sortFields[i].IsReverse ? -1 : 1;
+ m_reversed[i] = sortFields[i].IsReverse ? -1 : 1;
fields[i] = sortFields[i];
}
}
@@ -320,14 +320,14 @@ namespace Lucene.Net.Search.Grouping.Terms
groupHead = new GroupHead(this, doc, term);
collectedGroups.Add(groupHead);
segmentGroupHeads[key + 1] = groupHead;
- temporalResult.stop = true;
+ m_temporalResult.stop = true;
}
else
{
- temporalResult.stop = false;
+ m_temporalResult.stop = false;
groupHead = segmentGroupHeads[key + 1];
}
- temporalResult.groupHead = groupHead;
+ m_temporalResult.groupHead = groupHead;
}
public override void SetNextReader(AtomicReaderContext context)
@@ -510,7 +510,7 @@ namespace Lucene.Net.Search.Grouping.Terms
sortsIndex = new SortedDocValues[sortFields.Length];
for (int i = 0; i < sortFields.Length; i++)
{
- reversed[i] = sortFields[i].IsReverse ? -1 : 1;
+ m_reversed[i] = sortFields[i].IsReverse ? -1 : 1;
fields[i] = sortFields[i];
}
}
@@ -545,14 +545,14 @@ namespace Lucene.Net.Search.Grouping.Terms
groupHead = new GroupHead(this, doc, term);
collectedGroups.Add(groupHead);
segmentGroupHeads[key + 1] = groupHead;
- temporalResult.stop = true;
+ m_temporalResult.stop = true;
}
else
{
- temporalResult.stop = false;
+ m_temporalResult.stop = false;
groupHead = segmentGroupHeads[key + 1];
}
- temporalResult.groupHead = groupHead;
+ m_temporalResult.groupHead = groupHead;
}
public override void SetNextReader(AtomicReaderContext context)
@@ -693,7 +693,7 @@ namespace Lucene.Net.Search.Grouping.Terms
fields = new SortField[sortFields.Length];
for (int i = 0; i < sortFields.Length; i++)
{
- reversed[i] = sortFields[i].IsReverse ? -1 : 1;
+ m_reversed[i] = sortFields[i].IsReverse ? -1 : 1;
fields[i] = sortFields[i];
}
}
@@ -728,14 +728,14 @@ namespace Lucene.Net.Search.Grouping.Terms
groupHead = new GroupHead(this, doc, term);
collectedGroups.Add(groupHead);
segmentGroupHeads[key + 1] = groupHead;
- temporalResult.stop = true;
+ m_temporalResult.stop = true;
}
else
{
- temporalResult.stop = false;
+ m_temporalResult.stop = false;
groupHead = segmentGroupHeads[key + 1];
}
- temporalResult.groupHead = groupHead;
+ m_temporalResult.groupHead = groupHead;
}
public override void SetNextReader(AtomicReaderContext context)
{
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/d604cab9/src/Lucene.Net.Grouping/Term/TermGroupFacetCollector.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Grouping/Term/TermGroupFacetCollector.cs b/src/Lucene.Net.Grouping/Term/TermGroupFacetCollector.cs
index 7299f83..03ac2fd 100644
--- a/src/Lucene.Net.Grouping/Term/TermGroupFacetCollector.cs
+++ b/src/Lucene.Net.Grouping/Term/TermGroupFacetCollector.cs
@@ -88,7 +88,7 @@ namespace Lucene.Net.Search.Grouping.Terms
public override void Collect(int doc)
{
int facetOrd = facetFieldTermsIndex.GetOrd(doc);
- if (facetOrd < startFacetOrd || facetOrd >= endFacetOrd)
+ if (facetOrd < m_startFacetOrd || facetOrd >= m_endFacetOrd)
{
return;
}
@@ -100,8 +100,8 @@ namespace Lucene.Net.Search.Grouping.Terms
return;
}
- segmentTotalCount++;
- segmentFacetCounts[facetOrd + 1]++;
+ m_segmentTotalCount++;
+ m_segmentFacetCounts[facetOrd + 1]++;
segmentGroupedFacetHits.Put(segmentGroupedFacetsIndex);
@@ -132,17 +132,17 @@ namespace Lucene.Net.Search.Grouping.Terms
public override void SetNextReader(AtomicReaderContext context)
{
- if (segmentFacetCounts != null)
+ if (m_segmentFacetCounts != null)
{
- segmentResults.Add(CreateSegmentResult());
+ m_segmentResults.Add(CreateSegmentResult());
}
- groupFieldTermsIndex = FieldCache.DEFAULT.GetTermsIndex(context.AtomicReader, groupField);
- facetFieldTermsIndex = FieldCache.DEFAULT.GetTermsIndex(context.AtomicReader, facetField);
+ groupFieldTermsIndex = FieldCache.DEFAULT.GetTermsIndex(context.AtomicReader, m_groupField);
+ facetFieldTermsIndex = FieldCache.DEFAULT.GetTermsIndex(context.AtomicReader, m_facetField);
// 1+ to allow for the -1 "not set":
- segmentFacetCounts = new int[facetFieldTermsIndex.ValueCount + 1];
- segmentTotalCount = 0;
+ m_segmentFacetCounts = new int[facetFieldTermsIndex.ValueCount + 1];
+ m_segmentTotalCount = 0;
segmentGroupedFacetHits.Clear();
foreach (GroupedFacetHit groupedFacetHit in groupedFacetHits)
@@ -163,31 +163,31 @@ namespace Lucene.Net.Search.Grouping.Terms
segmentGroupedFacetHits.Put(segmentGroupedFacetsIndex);
}
- if (facetPrefix != null)
+ if (m_facetPrefix != null)
{
- startFacetOrd = facetFieldTermsIndex.LookupTerm(facetPrefix);
- if (startFacetOrd < 0)
+ m_startFacetOrd = facetFieldTermsIndex.LookupTerm(m_facetPrefix);
+ if (m_startFacetOrd < 0)
{
// Points to the ord one higher than facetPrefix
- startFacetOrd = -startFacetOrd - 1;
+ m_startFacetOrd = -m_startFacetOrd - 1;
}
- BytesRef facetEndPrefix = BytesRef.DeepCopyOf(facetPrefix);
+ BytesRef facetEndPrefix = BytesRef.DeepCopyOf(m_facetPrefix);
facetEndPrefix.Append(UnicodeUtil.BIG_TERM);
- endFacetOrd = facetFieldTermsIndex.LookupTerm(facetEndPrefix);
- Debug.Assert(endFacetOrd < 0);
- endFacetOrd = -endFacetOrd - 1; // Points to the ord one higher than facetEndPrefix
+ m_endFacetOrd = facetFieldTermsIndex.LookupTerm(facetEndPrefix);
+ Debug.Assert(m_endFacetOrd < 0);
+ m_endFacetOrd = -m_endFacetOrd - 1; // Points to the ord one higher than facetEndPrefix
}
else
{
- startFacetOrd = -1;
- endFacetOrd = facetFieldTermsIndex.ValueCount;
+ m_startFacetOrd = -1;
+ m_endFacetOrd = facetFieldTermsIndex.ValueCount;
}
}
protected override AbstractSegmentResult CreateSegmentResult()
{
- return new SegmentResult(segmentFacetCounts, segmentTotalCount, facetFieldTermsIndex.GetTermsEnum(), startFacetOrd, endFacetOrd);
+ return new SegmentResult(m_segmentFacetCounts, m_segmentTotalCount, facetFieldTermsIndex.GetTermsEnum(), m_startFacetOrd, m_endFacetOrd);
}
internal class SegmentResult : AbstractGroupFacetCollector.AbstractSegmentResult
@@ -199,18 +199,18 @@ namespace Lucene.Net.Search.Grouping.Terms
: base(counts, total - counts[0], counts[0], endFacetOrd + 1)
{
this.tenum = tenum;
- this.mergePos = startFacetOrd == -1 ? 1 : startFacetOrd + 1;
- if (mergePos < maxTermPos)
+ this.m_mergePos = startFacetOrd == -1 ? 1 : startFacetOrd + 1;
+ if (m_mergePos < m_maxTermPos)
{
Debug.Assert(tenum != null);
tenum.SeekExact(startFacetOrd == -1 ? 0 : startFacetOrd);
- mergeTerm = tenum.Term;
+ m_mergeTerm = tenum.Term;
}
}
protected internal override void NextTerm()
{
- mergeTerm = tenum.Next();
+ m_mergeTerm = tenum.Next();
}
}
}
@@ -237,13 +237,13 @@ namespace Lucene.Net.Search.Grouping.Terms
if (facetFieldNumTerms == 0)
{
int segmentGroupedFacetsIndex = groupOrd * (facetFieldNumTerms + 1);
- if (facetPrefix != null || segmentGroupedFacetHits.Exists(segmentGroupedFacetsIndex))
+ if (m_facetPrefix != null || segmentGroupedFacetHits.Exists(segmentGroupedFacetsIndex))
{
return;
}
- segmentTotalCount++;
- segmentFacetCounts[facetFieldNumTerms]++;
+ m_segmentTotalCount++;
+ m_segmentFacetCounts[facetFieldNumTerms]++;
segmentGroupedFacetHits.Put(segmentGroupedFacetsIndex);
BytesRef groupKey;
@@ -277,7 +277,7 @@ namespace Lucene.Net.Search.Grouping.Terms
private void Process(int groupOrd, int facetOrd)
{
- if (facetOrd < startFacetOrd || facetOrd >= endFacetOrd)
+ if (facetOrd < m_startFacetOrd || facetOrd >= m_endFacetOrd)
{
return;
}
@@ -288,8 +288,8 @@ namespace Lucene.Net.Search.Grouping.Terms
return;
}
- segmentTotalCount++;
- segmentFacetCounts[facetOrd]++;
+ m_segmentTotalCount++;
+ m_segmentFacetCounts[facetOrd]++;
segmentGroupedFacetHits.Put(segmentGroupedFacetsIndex);
@@ -319,13 +319,13 @@ namespace Lucene.Net.Search.Grouping.Terms
public override void SetNextReader(AtomicReaderContext context)
{
- if (segmentFacetCounts != null)
+ if (m_segmentFacetCounts != null)
{
- segmentResults.Add(CreateSegmentResult());
+ m_segmentResults.Add(CreateSegmentResult());
}
- groupFieldTermsIndex = FieldCache.DEFAULT.GetTermsIndex(context.AtomicReader, groupField);
- facetFieldDocTermOrds = FieldCache.DEFAULT.GetDocTermOrds(context.AtomicReader, facetField);
+ groupFieldTermsIndex = FieldCache.DEFAULT.GetTermsIndex(context.AtomicReader, m_groupField);
+ facetFieldDocTermOrds = FieldCache.DEFAULT.GetDocTermOrds(context.AtomicReader, m_facetField);
facetFieldNumTerms = (int)facetFieldDocTermOrds.ValueCount;
if (facetFieldNumTerms == 0)
{
@@ -336,8 +336,8 @@ namespace Lucene.Net.Search.Grouping.Terms
facetOrdTermsEnum = facetFieldDocTermOrds.GetTermsEnum();
}
// [facetFieldNumTerms() + 1] for all possible facet values and docs not containing facet field
- segmentFacetCounts = new int[facetFieldNumTerms + 1];
- segmentTotalCount = 0;
+ m_segmentFacetCounts = new int[facetFieldNumTerms + 1];
+ m_segmentTotalCount = 0;
segmentGroupedFacetHits.Clear();
foreach (GroupedFacetHit groupedFacetHit in groupedFacetHits)
@@ -367,12 +367,12 @@ namespace Lucene.Net.Search.Grouping.Terms
segmentGroupedFacetHits.Put(segmentGroupedFacetsIndex);
}
- if (facetPrefix != null)
+ if (m_facetPrefix != null)
{
TermsEnum.SeekStatus seekStatus;
if (facetOrdTermsEnum != null)
{
- seekStatus = facetOrdTermsEnum.SeekCeil(facetPrefix);
+ seekStatus = facetOrdTermsEnum.SeekCeil(m_facetPrefix);
}
else
{
@@ -381,37 +381,37 @@ namespace Lucene.Net.Search.Grouping.Terms
if (seekStatus != TermsEnum.SeekStatus.END)
{
- startFacetOrd = (int)facetOrdTermsEnum.Ord;
+ m_startFacetOrd = (int)facetOrdTermsEnum.Ord;
}
else
{
- startFacetOrd = 0;
- endFacetOrd = 0;
+ m_startFacetOrd = 0;
+ m_endFacetOrd = 0;
return;
}
- BytesRef facetEndPrefix = BytesRef.DeepCopyOf(facetPrefix);
+ BytesRef facetEndPrefix = BytesRef.DeepCopyOf(m_facetPrefix);
facetEndPrefix.Append(UnicodeUtil.BIG_TERM);
seekStatus = facetOrdTermsEnum.SeekCeil(facetEndPrefix);
if (seekStatus != TermsEnum.SeekStatus.END)
{
- endFacetOrd = (int)facetOrdTermsEnum.Ord;
+ m_endFacetOrd = (int)facetOrdTermsEnum.Ord;
}
else
{
- endFacetOrd = facetFieldNumTerms; // Don't include null...
+ m_endFacetOrd = facetFieldNumTerms; // Don't include null...
}
}
else
{
- startFacetOrd = 0;
- endFacetOrd = facetFieldNumTerms + 1;
+ m_startFacetOrd = 0;
+ m_endFacetOrd = facetFieldNumTerms + 1;
}
}
protected override AbstractSegmentResult CreateSegmentResult()
{
- return new SegmentResult(segmentFacetCounts, segmentTotalCount, facetFieldNumTerms, facetOrdTermsEnum, startFacetOrd, endFacetOrd);
+ return new SegmentResult(m_segmentFacetCounts, m_segmentTotalCount, facetFieldNumTerms, facetOrdTermsEnum, m_startFacetOrd, m_endFacetOrd);
}
internal class SegmentResult : AbstractGroupFacetCollector.AbstractSegmentResult
@@ -424,17 +424,17 @@ namespace Lucene.Net.Search.Grouping.Terms
endFacetOrd == missingCountIndex + 1 ? missingCountIndex : endFacetOrd)
{
this.tenum = tenum;
- this.mergePos = startFacetOrd;
+ this.m_mergePos = startFacetOrd;
if (tenum != null)
{
- tenum.SeekExact(mergePos);
- mergeTerm = tenum.Term;
+ tenum.SeekExact(m_mergePos);
+ m_mergeTerm = tenum.Term;
}
}
protected internal override void NextTerm()
{
- mergeTerm = tenum.Next();
+ m_mergeTerm = tenum.Next();
}
}
}
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/d604cab9/src/Lucene.Net.Grouping/Term/TermSecondPassGroupingCollector.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Grouping/Term/TermSecondPassGroupingCollector.cs b/src/Lucene.Net.Grouping/Term/TermSecondPassGroupingCollector.cs
index 43328d5..c84af50 100644
--- a/src/Lucene.Net.Grouping/Term/TermSecondPassGroupingCollector.cs
+++ b/src/Lucene.Net.Grouping/Term/TermSecondPassGroupingCollector.cs
@@ -38,9 +38,9 @@ namespace Lucene.Net.Search.Grouping.Terms
int maxDocsPerGroup, bool getScores, bool getMaxScores, bool fillSortFields)
: base(groups, groupSort, withinGroupSort, maxDocsPerGroup, getScores, getMaxScores, fillSortFields)
{
- ordSet = new SentinelIntSet(groupMap.Count, -2);
+ ordSet = new SentinelIntSet(m_groupMap.Count, -2);
this.groupField = groupField;
- groupDocs = /*(SearchGroupDocs<BytesRef>[])*/ new AbstractSecondPassGroupingCollector.SearchGroupDocs<BytesRef>[ordSet.Keys.Length];
+ m_groupDocs = /*(SearchGroupDocs<BytesRef>[])*/ new AbstractSecondPassGroupingCollector.SearchGroupDocs<BytesRef>[ordSet.Keys.Length];
}
public override void SetNextReader(AtomicReaderContext context)
@@ -50,13 +50,13 @@ namespace Lucene.Net.Search.Grouping.Terms
// Rebuild ordSet
ordSet.Clear();
- foreach (AbstractSecondPassGroupingCollector.SearchGroupDocs<BytesRef> group in groupMap.Values)
+ foreach (AbstractSecondPassGroupingCollector.SearchGroupDocs<BytesRef> group in m_groupMap.Values)
{
// System.out.println(" group=" + (group.groupValue == null ? "null" : group.groupValue.utf8ToString()));
int ord = group.groupValue == null ? -1 : index.LookupTerm(group.groupValue);
if (group.groupValue == null || ord >= 0)
{
- groupDocs[ordSet.Put(ord)] = group;
+ m_groupDocs[ordSet.Put(ord)] = group;
}
}
}
@@ -66,7 +66,7 @@ namespace Lucene.Net.Search.Grouping.Terms
int slot = ordSet.Find(index.GetOrd(doc));
if (slot >= 0)
{
- return groupDocs[slot];
+ return m_groupDocs[slot];
}
return null;
}
[27/28] lucenenet git commit:
Lucene.Net.Analysis.Stempel.RectangularArrays: renamed
ReturnRectangualarIntArray() > ReturnRectangualarInt32Array()
Posted by ni...@apache.org.
Lucene.Net.Analysis.Stempel.RectangularArrays: renamed ReturnRectangualarIntArray() > ReturnRectangualarInt32Array()
Project: http://git-wip-us.apache.org/repos/asf/lucenenet/repo
Commit: http://git-wip-us.apache.org/repos/asf/lucenenet/commit/a3324302
Tree: http://git-wip-us.apache.org/repos/asf/lucenenet/tree/a3324302
Diff: http://git-wip-us.apache.org/repos/asf/lucenenet/diff/a3324302
Branch: refs/heads/api-work
Commit: a3324302cdcf607169284a201cad2d207dd4a527
Parents: 49e5b7a
Author: Shad Storhaug <sh...@shadstorhaug.com>
Authored: Wed Feb 1 17:09:07 2017 +0700
Committer: Shad Storhaug <sh...@shadstorhaug.com>
Committed: Wed Feb 1 17:09:07 2017 +0700
----------------------------------------------------------------------
src/Lucene.Net.Analysis.Stempel/Egothor.Stemmer/Diff.cs | 4 ++--
src/Lucene.Net.Analysis.Stempel/RectangularArrays.cs | 2 +-
2 files changed, 3 insertions(+), 3 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/a3324302/src/Lucene.Net.Analysis.Stempel/Egothor.Stemmer/Diff.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Analysis.Stempel/Egothor.Stemmer/Diff.cs b/src/Lucene.Net.Analysis.Stempel/Egothor.Stemmer/Diff.cs
index e5e372e..8f149a9 100644
--- a/src/Lucene.Net.Analysis.Stempel/Egothor.Stemmer/Diff.cs
+++ b/src/Lucene.Net.Analysis.Stempel/Egothor.Stemmer/Diff.cs
@@ -198,8 +198,8 @@ namespace Egothor.Stemmer
{
sizex = maxx + 8;
sizey = maxy + 8;
- net = RectangularArrays.ReturnRectangularIntArray(sizex, sizey);
- way = RectangularArrays.ReturnRectangularIntArray(sizex, sizey);
+ net = RectangularArrays.ReturnRectangularInt32Array(sizex, sizey);
+ way = RectangularArrays.ReturnRectangularInt32Array(sizex, sizey);
}
/*
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/a3324302/src/Lucene.Net.Analysis.Stempel/RectangularArrays.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Analysis.Stempel/RectangularArrays.cs b/src/Lucene.Net.Analysis.Stempel/RectangularArrays.cs
index 09fe264..2f2dbd0 100644
--- a/src/Lucene.Net.Analysis.Stempel/RectangularArrays.cs
+++ b/src/Lucene.Net.Analysis.Stempel/RectangularArrays.cs
@@ -10,7 +10,7 @@ using Lucene.Net.Util;
internal static partial class RectangularArrays
{
- internal static int[][] ReturnRectangularIntArray(int size1, int size2)
+ internal static int[][] ReturnRectangularInt32Array(int size1, int size2)
{
int[][] Array;
if (size1 > -1)
[18/28] lucenenet git commit: Lucene.Net.Grouping refactor: Changed
all public fields into properties
Posted by ni...@apache.org.
Lucene.Net.Grouping refactor: Changed all public fields into properties
Project: http://git-wip-us.apache.org/repos/asf/lucenenet/repo
Commit: http://git-wip-us.apache.org/repos/asf/lucenenet/commit/378f1f12
Tree: http://git-wip-us.apache.org/repos/asf/lucenenet/tree/378f1f12
Diff: http://git-wip-us.apache.org/repos/asf/lucenenet/diff/378f1f12
Branch: refs/heads/api-work
Commit: 378f1f126a6006237b8ff0eaabb3d7d704858c8f
Parents: 1dccd77
Author: Shad Storhaug <sh...@shadstorhaug.com>
Authored: Wed Feb 1 16:06:07 2017 +0700
Committer: Shad Storhaug <sh...@shadstorhaug.com>
Committed: Wed Feb 1 16:06:07 2017 +0700
----------------------------------------------------------------------
.../AbstractAllGroupHeadsCollector.cs | 10 +-
.../AbstractSecondPassGroupingCollector.cs | 23 ++--
.../Function/FunctionAllGroupHeadsCollector.cs | 12 +-
src/Lucene.Net.Grouping/SearchGroup.cs | 123 ++++++++++++++-----
.../Term/TermAllGroupHeadsCollector.cs | 66 ++++++----
.../Term/TermSecondPassGroupingCollector.cs | 4 +-
6 files changed, 161 insertions(+), 77 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/378f1f12/src/Lucene.Net.Grouping/AbstractAllGroupHeadsCollector.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Grouping/AbstractAllGroupHeadsCollector.cs b/src/Lucene.Net.Grouping/AbstractAllGroupHeadsCollector.cs
index f5f5ad0..2fb3d59 100644
--- a/src/Lucene.Net.Grouping/AbstractAllGroupHeadsCollector.cs
+++ b/src/Lucene.Net.Grouping/AbstractAllGroupHeadsCollector.cs
@@ -93,7 +93,7 @@ namespace Lucene.Net.Search.Grouping
/// Returns the group head and puts it into <see cref="TemporalResult"/>.
/// If the group head wasn't encountered before then it will be added to the collected group heads.
/// <para>
- /// The <see cref="TemporalResult.stop"/> property will be <c>true</c> if the group head wasn't encountered before
+ /// The <see cref="TemporalResult.Stop"/> property will be <c>true</c> if the group head wasn't encountered before
/// otherwise <c>false</c>.
/// </para>
/// </summary>
@@ -111,11 +111,11 @@ namespace Lucene.Net.Search.Grouping
public override void Collect(int doc)
{
RetrieveGroupHeadAndAddIfNotExist(doc);
- if (m_temporalResult.stop)
+ if (m_temporalResult.Stop)
{
return;
}
- GH groupHead = m_temporalResult.groupHead;
+ GH groupHead = m_temporalResult.GroupHead;
// Ok now we need to check if the current doc is more relevant then current doc for this group
for (int compIDX = 0; ; compIDX++)
@@ -153,8 +153,8 @@ namespace Lucene.Net.Search.Grouping
/// </summary>
protected class TemporalResult
{
- public GH groupHead;
- public bool stop;
+ public GH GroupHead { get; set; }
+ public bool Stop { get; set; }
}
}
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/378f1f12/src/Lucene.Net.Grouping/AbstractSecondPassGroupingCollector.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Grouping/AbstractSecondPassGroupingCollector.cs b/src/Lucene.Net.Grouping/AbstractSecondPassGroupingCollector.cs
index deb44a3..ee75c57 100644
--- a/src/Lucene.Net.Grouping/AbstractSecondPassGroupingCollector.cs
+++ b/src/Lucene.Net.Grouping/AbstractSecondPassGroupingCollector.cs
@@ -86,7 +86,7 @@ namespace Lucene.Net.Search.Grouping
{
foreach (AbstractSecondPassGroupingCollector.SearchGroupDocs<TGroupValue> group in m_groupMap.Values)
{
- group.collector.SetScorer(scorer);
+ group.Collector.SetScorer(scorer);
}
}
@@ -97,7 +97,7 @@ namespace Lucene.Net.Search.Grouping
if (group != null)
{
totalGroupedHitCount++;
- group.collector.Collect(doc);
+ group.Collector.Collect(doc);
}
}
@@ -114,7 +114,7 @@ namespace Lucene.Net.Search.Grouping
//System.out.println("SP.setNextReader");
foreach (AbstractSecondPassGroupingCollector.SearchGroupDocs<TGroupValue> group in m_groupMap.Values)
{
- group.collector.SetNextReader(context);
+ group.Collector.SetNextReader(context);
}
}
@@ -132,12 +132,12 @@ namespace Lucene.Net.Search.Grouping
foreach (var group in groups)
{
AbstractSecondPassGroupingCollector.SearchGroupDocs<TGroupValue> groupDocs = m_groupMap.ContainsKey(group.GroupValue) ? m_groupMap[group.GroupValue] : null;
- TopDocs topDocs = groupDocs.collector.GetTopDocs(withinGroupOffset, maxDocsPerGroup);
+ TopDocs topDocs = groupDocs.Collector.GetTopDocs(withinGroupOffset, maxDocsPerGroup);
groupDocsResult[groupIDX++] = new GroupDocs<TGroupValue>(float.NaN,
topDocs.MaxScore,
topDocs.TotalHits,
topDocs.ScoreDocs,
- groupDocs.groupValue,
+ groupDocs.GroupValue,
group.SortValues);
maxScore = Math.Max(maxScore, topDocs.MaxScore);
}
@@ -169,8 +169,17 @@ namespace Lucene.Net.Search.Grouping
// disad: blows up the size of SearchGroup if we need many of them, and couples implementations
public class SearchGroupDocs<TGroupValue>
{
- public readonly TGroupValue groupValue;
- public readonly ITopDocsCollector collector;
+ public TGroupValue GroupValue
+ {
+ get { return groupValue; }
+ }
+ private readonly TGroupValue groupValue;
+
+ public ITopDocsCollector Collector
+ {
+ get { return collector; }
+ }
+ private readonly ITopDocsCollector collector;
public SearchGroupDocs(TGroupValue groupValue, ITopDocsCollector collector)
{
this.groupValue = groupValue;
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/378f1f12/src/Lucene.Net.Grouping/Function/FunctionAllGroupHeadsCollector.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Grouping/Function/FunctionAllGroupHeadsCollector.cs b/src/Lucene.Net.Grouping/Function/FunctionAllGroupHeadsCollector.cs
index 6ca3cdf..98f435e 100644
--- a/src/Lucene.Net.Grouping/Function/FunctionAllGroupHeadsCollector.cs
+++ b/src/Lucene.Net.Grouping/Function/FunctionAllGroupHeadsCollector.cs
@@ -71,13 +71,13 @@ namespace Lucene.Net.Search.Grouping.Function
MutableValue groupValue = mval.Duplicate();
groupHead = new GroupHead(this, groupValue, sortWithinGroup, doc);
groups[groupValue] = groupHead;
- m_temporalResult.stop = true;
+ m_temporalResult.Stop = true;
}
else
{
- m_temporalResult.stop = false;
+ m_temporalResult.Stop = false;
}
- this.m_temporalResult.groupHead = groupHead;
+ this.m_temporalResult.GroupHead = groupHead;
}
protected override ICollection<GroupHead> CollectedGroupHeads
@@ -124,7 +124,11 @@ namespace Lucene.Net.Search.Grouping.Function
private readonly FunctionAllGroupHeadsCollector outerInstance;
// LUCENENET: Moved this here from the base class, AbstractAllGroupHeadsCollector_GroupHead so it doesn't
// need to reference the generic closing type MutableValue.
- public readonly MutableValue groupValue;
+ public MutableValue GroupValue
+ {
+ get { return groupValue; }
+ }
+ private readonly MutableValue groupValue;
internal readonly FieldComparer[] comparers;
internal GroupHead(FunctionAllGroupHeadsCollector outerInstance, MutableValue groupValue, Sort sort, int doc)
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/378f1f12/src/Lucene.Net.Grouping/SearchGroup.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Grouping/SearchGroup.cs b/src/Lucene.Net.Grouping/SearchGroup.cs
index cad33f3..a5e6cd5 100644
--- a/src/Lucene.Net.Grouping/SearchGroup.cs
+++ b/src/Lucene.Net.Grouping/SearchGroup.cs
@@ -94,8 +94,17 @@ namespace Lucene.Net.Search.Grouping
private class ShardIter<T>
{
- public readonly IEnumerator<ISearchGroup<T>> iter;
- public readonly int shardIndex;
+ public IEnumerator<ISearchGroup<T>> Iter
+ {
+ get { return iter; }
+ }
+ private readonly IEnumerator<ISearchGroup<T>> iter;
+
+ public int ShardIndex
+ {
+ get { return shardIndex; }
+ }
+ private readonly int shardIndex;
public ShardIter(IEnumerable<ISearchGroup<T>> shard, int shardIndex)
{
@@ -129,13 +138,47 @@ namespace Lucene.Net.Search.Grouping
{
// groupValue may be null!
- public readonly T groupValue;
+ public T GroupValue
+ {
+ get { return groupValue; }
+ }
+ private readonly T groupValue;
- public object[] topValues;
- public readonly List<ShardIter<T>> shards = new List<ShardIter<T>>();
- public int minShardIndex;
- public bool processed;
- public bool inQueue;
+ [WritableArray]
+ [SuppressMessage("Microsoft.Performance", "CA1819", Justification = "Lucene's design requires some writable array properties")]
+ public object[] TopValues
+ {
+ get { return topValues; }
+ set { topValues = value; }
+ }
+ private object[] topValues;
+
+ public IList<ShardIter<T>> Shards
+ {
+ get { return shards; }
+ }
+ private readonly List<ShardIter<T>> shards = new List<ShardIter<T>>();
+
+ public int MinShardIndex
+ {
+ get { return minShardIndex; }
+ set { minShardIndex = value; }
+ }
+ private int minShardIndex;
+
+ public bool IsProcessed
+ {
+ get { return processed; }
+ set { processed = value; }
+ }
+ private bool processed;
+
+ public bool IsInQueue
+ {
+ get { return inQueue; }
+ set { inQueue = value; }
+ }
+ private bool inQueue;
public MergedGroup(T groupValue)
{
@@ -199,9 +242,21 @@ namespace Lucene.Net.Search.Grouping
private class GroupComparer<T> : IComparer<MergedGroup<T>>
{
+ [WritableArray]
+ [SuppressMessage("Microsoft.Performance", "CA1819", Justification = "Lucene's design requires some writable array properties")]
+ public FieldComparer[] Comparers
+ {
+ get { return comparers; }
+ }
+ private readonly FieldComparer[] comparers;
- public readonly FieldComparer[] comparers;
- public readonly int[] reversed;
+ [WritableArray]
+ [SuppressMessage("Microsoft.Performance", "CA1819", Justification = "Lucene's design requires some writable array properties")]
+ public int[] Reversed
+ {
+ get { return reversed; }
+ }
+ private readonly int[] reversed;
public GroupComparer(Sort groupSort)
{
@@ -223,8 +278,8 @@ namespace Lucene.Net.Search.Grouping
return 0;
}
//System.out.println("compare group=" + group + " other=" + other);
- object[] groupValues = group.topValues;
- object[] otherValues = other.topValues;
+ object[] groupValues = group.TopValues;
+ object[] otherValues = other.TopValues;
//System.out.println(" groupValues=" + groupValues + " otherValues=" + otherValues);
for (int compIDX = 0; compIDX < comparers.Length; compIDX++)
{
@@ -237,8 +292,8 @@ namespace Lucene.Net.Search.Grouping
}
// Tie break by min shard index:
- Debug.Assert(group.minShardIndex != other.minShardIndex);
- return group.minShardIndex - other.minShardIndex;
+ Debug.Assert(group.MinShardIndex != other.MinShardIndex);
+ return group.MinShardIndex - other.MinShardIndex;
}
}
@@ -258,7 +313,7 @@ namespace Lucene.Net.Search.Grouping
private void UpdateNextGroup(int topN, ShardIter<T> shard)
{
- while (shard.iter.MoveNext())
+ while (shard.Iter.MoveNext())
{
ISearchGroup<T> group = shard.Next();
MergedGroup<T> mergedGroup = groupsSeen.ContainsKey(group.GroupValue) ? groupsSeen[group.GroupValue] : null;
@@ -270,14 +325,14 @@ namespace Lucene.Net.Search.Grouping
// Start a new group:
//System.out.println(" new");
mergedGroup = new MergedGroup<T>(group.GroupValue);
- mergedGroup.minShardIndex = shard.shardIndex;
+ mergedGroup.MinShardIndex = shard.ShardIndex;
Debug.Assert(group.SortValues != null);
- mergedGroup.topValues = group.SortValues;
+ mergedGroup.TopValues = group.SortValues;
groupsSeen[group.GroupValue] = mergedGroup;
- mergedGroup.inQueue = true;
+ mergedGroup.IsInQueue = true;
queue.Add(mergedGroup);
}
- else if (mergedGroup.processed)
+ else if (mergedGroup.IsProcessed)
{
// This shard produced a group that we already
// processed; move on to next group...
@@ -287,10 +342,10 @@ namespace Lucene.Net.Search.Grouping
{
//System.out.println(" old");
bool competes = false;
- for (int compIDX = 0; compIDX < groupComp.comparers.Length; compIDX++)
+ for (int compIDX = 0; compIDX < groupComp.Comparers.Length; compIDX++)
{
- int cmp = groupComp.reversed[compIDX] * groupComp.comparers[compIDX].CompareValues(group.SortValues[compIDX],
- mergedGroup.topValues[compIDX]);
+ int cmp = groupComp.Reversed[compIDX] * groupComp.Comparers[compIDX].CompareValues(group.SortValues[compIDX],
+ mergedGroup.TopValues[compIDX]);
if (cmp < 0)
{
// Definitely competes
@@ -302,9 +357,9 @@ namespace Lucene.Net.Search.Grouping
// Definitely does not compete
break;
}
- else if (compIDX == groupComp.comparers.Length - 1)
+ else if (compIDX == groupComp.Comparers.Length - 1)
{
- if (shard.shardIndex < mergedGroup.minShardIndex)
+ if (shard.ShardIndex < mergedGroup.MinShardIndex)
{
competes = true;
}
@@ -316,18 +371,18 @@ namespace Lucene.Net.Search.Grouping
if (competes)
{
// Group's sort changed -- remove & re-insert
- if (mergedGroup.inQueue)
+ if (mergedGroup.IsInQueue)
{
queue.Remove(mergedGroup);
}
- mergedGroup.topValues = group.SortValues;
- mergedGroup.minShardIndex = shard.shardIndex;
+ mergedGroup.TopValues = group.SortValues;
+ mergedGroup.MinShardIndex = shard.ShardIndex;
queue.Add(mergedGroup);
- mergedGroup.inQueue = true;
+ mergedGroup.IsInQueue = true;
}
}
- mergedGroup.shards.Add(shard);
+ mergedGroup.Shards.Add(shard);
break;
}
@@ -337,7 +392,7 @@ namespace Lucene.Net.Search.Grouping
MergedGroup<T> group = queue.Last();
queue.Remove(group);
//System.out.println("PRUNE: " + group);
- group.inQueue = false;
+ group.IsInQueue = false;
}
}
@@ -367,13 +422,13 @@ namespace Lucene.Net.Search.Grouping
{
MergedGroup<T> group = queue.First();
queue.Remove(group);
- group.processed = true;
+ group.IsProcessed = true;
//System.out.println(" pop: shards=" + group.shards + " group=" + (group.groupValue == null ? "null" : (((BytesRef) group.groupValue).utf8ToString())) + " sortValues=" + Arrays.toString(group.topValues));
if (count++ >= offset)
{
SearchGroup<T> newGroup = new SearchGroup<T>();
- newGroup.GroupValue = group.groupValue;
- newGroup.SortValues = group.topValues;
+ newGroup.GroupValue = group.GroupValue;
+ newGroup.SortValues = group.TopValues;
newTopGroups.Add(newGroup);
if (newTopGroups.Count == topN)
{
@@ -384,7 +439,7 @@ namespace Lucene.Net.Search.Grouping
}
// Advance all iters in this group:
- foreach (ShardIter<T> shardIter in group.shards)
+ foreach (ShardIter<T> shardIter in group.Shards)
{
UpdateNextGroup(maxQueueSize, shardIter);
}
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/378f1f12/src/Lucene.Net.Grouping/Term/TermAllGroupHeadsCollector.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Grouping/Term/TermAllGroupHeadsCollector.cs b/src/Lucene.Net.Grouping/Term/TermAllGroupHeadsCollector.cs
index 88ab3ce..8961fed 100644
--- a/src/Lucene.Net.Grouping/Term/TermAllGroupHeadsCollector.cs
+++ b/src/Lucene.Net.Grouping/Term/TermAllGroupHeadsCollector.cs
@@ -176,13 +176,13 @@ namespace Lucene.Net.Search.Grouping.Terms
{
groupHead = new GroupHead(this, groupValue, sortWithinGroup, doc);
groups[groupValue == null ? null : BytesRef.DeepCopyOf(groupValue)] = groupHead;
- m_temporalResult.stop = true;
+ m_temporalResult.Stop = true;
}
else
{
- m_temporalResult.stop = false;
+ m_temporalResult.Stop = false;
}
- m_temporalResult.groupHead = groupHead;
+ m_temporalResult.GroupHead = groupHead;
}
protected override ICollection<GroupHead> CollectedGroupHeads
@@ -221,7 +221,11 @@ namespace Lucene.Net.Search.Grouping.Terms
private readonly GeneralAllGroupHeadsCollector outerInstance;
// LUCENENET: Moved groupValue here from the base class, AbstractAllGroupHeadsCollector_GroupHead so it doesn't
// need to reference the generic closing type BytesRef.
- public readonly BytesRef groupValue;
+ public BytesRef GroupValue
+ {
+ get { return groupValue; }
+ }
+ private readonly BytesRef groupValue;
internal readonly FieldComparer[] comparers;
@@ -320,14 +324,14 @@ namespace Lucene.Net.Search.Grouping.Terms
groupHead = new GroupHead(this, doc, term);
collectedGroups.Add(groupHead);
segmentGroupHeads[key + 1] = groupHead;
- m_temporalResult.stop = true;
+ m_temporalResult.Stop = true;
}
else
{
- m_temporalResult.stop = false;
+ m_temporalResult.Stop = false;
groupHead = segmentGroupHeads[key + 1];
}
- m_temporalResult.groupHead = groupHead;
+ m_temporalResult.GroupHead = groupHead;
}
public override void SetNextReader(AtomicReaderContext context)
@@ -350,15 +354,15 @@ namespace Lucene.Net.Search.Grouping.Terms
foreach (GroupHead collectedGroup in collectedGroups)
{
int ord;
- if (collectedGroup.groupValue == null)
+ if (collectedGroup.GroupValue == null)
{
ord = -1;
}
else
{
- ord = groupIndex.LookupTerm(collectedGroup.groupValue);
+ ord = groupIndex.LookupTerm(collectedGroup.GroupValue);
}
- if (collectedGroup.groupValue == null || ord >= 0)
+ if (collectedGroup.GroupValue == null || ord >= 0)
{
ordSet.Put(ord);
segmentGroupHeads[ord + 1] = collectedGroup;
@@ -390,7 +394,11 @@ namespace Lucene.Net.Search.Grouping.Terms
private readonly OrdScoreAllGroupHeadsCollector outerInstance;
// LUCENENET: Moved groupValue here from the base class, AbstractAllGroupHeadsCollector_GroupHead so it doesn't
// need to reference the generic closing type BytesRef.
- public readonly BytesRef groupValue;
+ public BytesRef GroupValue
+ {
+ get { return groupValue; }
+ }
+ private readonly BytesRef groupValue;
internal BytesRef[] sortValues;
internal int[] sortOrds;
@@ -545,14 +553,14 @@ namespace Lucene.Net.Search.Grouping.Terms
groupHead = new GroupHead(this, doc, term);
collectedGroups.Add(groupHead);
segmentGroupHeads[key + 1] = groupHead;
- m_temporalResult.stop = true;
+ m_temporalResult.Stop = true;
}
else
{
- m_temporalResult.stop = false;
+ m_temporalResult.Stop = false;
groupHead = segmentGroupHeads[key + 1];
}
- m_temporalResult.groupHead = groupHead;
+ m_temporalResult.GroupHead = groupHead;
}
public override void SetNextReader(AtomicReaderContext context)
@@ -570,15 +578,15 @@ namespace Lucene.Net.Search.Grouping.Terms
foreach (GroupHead collectedGroup in collectedGroups)
{
int groupOrd;
- if (collectedGroup.groupValue == null)
+ if (collectedGroup.GroupValue == null)
{
groupOrd = -1;
}
else
{
- groupOrd = groupIndex.LookupTerm(collectedGroup.groupValue);
+ groupOrd = groupIndex.LookupTerm(collectedGroup.GroupValue);
}
- if (collectedGroup.groupValue == null || groupOrd >= 0)
+ if (collectedGroup.GroupValue == null || groupOrd >= 0)
{
ordSet.Put(groupOrd);
segmentGroupHeads[groupOrd + 1] = collectedGroup;
@@ -605,7 +613,11 @@ namespace Lucene.Net.Search.Grouping.Terms
private readonly OrdAllGroupHeadsCollector outerInstance;
// LUCENENET: Moved groupValue here from the base class, AbstractAllGroupHeadsCollector_GroupHead so it doesn't
// need to reference the generic closing type BytesRef.
- public readonly BytesRef groupValue;
+ public BytesRef GroupValue
+ {
+ get { return groupValue; }
+ }
+ private readonly BytesRef groupValue;
internal BytesRef[] sortValues;
internal int[] sortOrds;
@@ -728,14 +740,14 @@ namespace Lucene.Net.Search.Grouping.Terms
groupHead = new GroupHead(this, doc, term);
collectedGroups.Add(groupHead);
segmentGroupHeads[key + 1] = groupHead;
- m_temporalResult.stop = true;
+ m_temporalResult.Stop = true;
}
else
{
- m_temporalResult.stop = false;
+ m_temporalResult.Stop = false;
groupHead = segmentGroupHeads[key + 1];
}
- m_temporalResult.groupHead = groupHead;
+ m_temporalResult.GroupHead = groupHead;
}
public override void SetNextReader(AtomicReaderContext context)
{
@@ -748,15 +760,15 @@ namespace Lucene.Net.Search.Grouping.Terms
foreach (GroupHead collectedGroup in collectedGroups)
{
int ord;
- if (collectedGroup.groupValue == null)
+ if (collectedGroup.GroupValue == null)
{
ord = -1;
}
else
{
- ord = groupIndex.LookupTerm(collectedGroup.groupValue);
+ ord = groupIndex.LookupTerm(collectedGroup.GroupValue);
}
- if (collectedGroup.groupValue == null || ord >= 0)
+ if (collectedGroup.GroupValue == null || ord >= 0)
{
ordSet.Put(ord);
segmentGroupHeads[ord + 1] = collectedGroup;
@@ -769,7 +781,11 @@ namespace Lucene.Net.Search.Grouping.Terms
private readonly ScoreAllGroupHeadsCollector outerInstance;
// LUCENENET: Moved groupValue here from the base class, AbstractAllGroupHeadsCollector_GroupHead so it doesn't
// need to reference the generic closing type BytesRef.
- public readonly BytesRef groupValue;
+ public BytesRef GroupValue
+ {
+ get { return groupValue; }
+ }
+ private readonly BytesRef groupValue;
internal float[] scores;
internal GroupHead(ScoreAllGroupHeadsCollector outerInstance, int doc, BytesRef groupValue)
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/378f1f12/src/Lucene.Net.Grouping/Term/TermSecondPassGroupingCollector.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Grouping/Term/TermSecondPassGroupingCollector.cs b/src/Lucene.Net.Grouping/Term/TermSecondPassGroupingCollector.cs
index c84af50..a0924a6 100644
--- a/src/Lucene.Net.Grouping/Term/TermSecondPassGroupingCollector.cs
+++ b/src/Lucene.Net.Grouping/Term/TermSecondPassGroupingCollector.cs
@@ -53,8 +53,8 @@ namespace Lucene.Net.Search.Grouping.Terms
foreach (AbstractSecondPassGroupingCollector.SearchGroupDocs<BytesRef> group in m_groupMap.Values)
{
// System.out.println(" group=" + (group.groupValue == null ? "null" : group.groupValue.utf8ToString()));
- int ord = group.groupValue == null ? -1 : index.LookupTerm(group.groupValue);
- if (group.groupValue == null || ord >= 0)
+ int ord = group.GroupValue == null ? -1 : index.LookupTerm(group.GroupValue);
+ if (group.GroupValue == null || ord >= 0)
{
m_groupDocs[ordSet.Put(ord)] = group;
}
[12/28] lucenenet git commit:
Lucene.Net.Highlighter.RectangularArrays.ReturnRectangularStringArray():renamed
parameters camelCase
Posted by ni...@apache.org.
Lucene.Net.Highlighter.RectangularArrays.ReturnRectangularStringArray():renamed parameters camelCase
Project: http://git-wip-us.apache.org/repos/asf/lucenenet/repo
Commit: http://git-wip-us.apache.org/repos/asf/lucenenet/commit/8706ebbf
Tree: http://git-wip-us.apache.org/repos/asf/lucenenet/tree/8706ebbf
Diff: http://git-wip-us.apache.org/repos/asf/lucenenet/diff/8706ebbf
Branch: refs/heads/api-work
Commit: 8706ebbf2ce46caa9c7573e388f5502efe109bd9
Parents: 350040c
Author: Shad Storhaug <sh...@shadstorhaug.com>
Authored: Wed Feb 1 14:04:43 2017 +0700
Committer: Shad Storhaug <sh...@shadstorhaug.com>
Committed: Wed Feb 1 14:04:43 2017 +0700
----------------------------------------------------------------------
src/Lucene.Net.Highlighter/RectangularArrays.cs | 12 ++++++------
1 file changed, 6 insertions(+), 6 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8706ebbf/src/Lucene.Net.Highlighter/RectangularArrays.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Highlighter/RectangularArrays.cs b/src/Lucene.Net.Highlighter/RectangularArrays.cs
index 0aa5151..03f65dd 100644
--- a/src/Lucene.Net.Highlighter/RectangularArrays.cs
+++ b/src/Lucene.Net.Highlighter/RectangularArrays.cs
@@ -7,17 +7,17 @@
//----------------------------------------------------------------------------------------
internal static partial class RectangularArrays
{
- internal static string[][] ReturnRectangularStringArray(int Size1, int Size2)
+ internal static string[][] ReturnRectangularStringArray(int size1, int size2)
{
string[][] Array;
- if (Size1 > -1)
+ if (size1 > -1)
{
- Array = new string[Size1][];
- if (Size2 > -1)
+ Array = new string[size1][];
+ if (size2 > -1)
{
- for (int Array1 = 0; Array1 < Size1; Array1++)
+ for (int Array1 = 0; Array1 < size1; Array1++)
{
- Array[Array1] = new string[Size2];
+ Array[Array1] = new string[size2];
}
}
}
[23/28] lucenenet git commit: Lucene.Net.Tests.Classification: Added
API consistency tests
Posted by ni...@apache.org.
Lucene.Net.Tests.Classification: Added API consistency tests
Project: http://git-wip-us.apache.org/repos/asf/lucenenet/repo
Commit: http://git-wip-us.apache.org/repos/asf/lucenenet/commit/c84e63a7
Tree: http://git-wip-us.apache.org/repos/asf/lucenenet/tree/c84e63a7
Diff: http://git-wip-us.apache.org/repos/asf/lucenenet/diff/c84e63a7
Branch: refs/heads/api-work
Commit: c84e63a792b1dcd8e8df93bc312f05391d94434c
Parents: ba13cf4
Author: Shad Storhaug <sh...@shadstorhaug.com>
Authored: Wed Feb 1 17:01:51 2017 +0700
Committer: Shad Storhaug <sh...@shadstorhaug.com>
Committed: Wed Feb 1 17:01:51 2017 +0700
----------------------------------------------------------------------
.../Lucene.Net.Tests.Classification.csproj | 1 +
.../TestApiConsistency.cs | 120 +++++++++++++++++++
2 files changed, 121 insertions(+)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c84e63a7/src/Lucene.Net.Tests.Classification/Lucene.Net.Tests.Classification.csproj
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Classification/Lucene.Net.Tests.Classification.csproj b/src/Lucene.Net.Tests.Classification/Lucene.Net.Tests.Classification.csproj
index d302a0f..0eec295 100644
--- a/src/Lucene.Net.Tests.Classification/Lucene.Net.Tests.Classification.csproj
+++ b/src/Lucene.Net.Tests.Classification/Lucene.Net.Tests.Classification.csproj
@@ -43,6 +43,7 @@
<Compile Include="KNearestNeighborClassifierTest.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />
<Compile Include="SimpleNaiveBayesClassifierTest.cs" />
+ <Compile Include="TestApiConsistency.cs" />
<Compile Include="Utils\DataSplitterTest.cs" />
</ItemGroup>
<ItemGroup>
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c84e63a7/src/Lucene.Net.Tests.Classification/TestApiConsistency.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Classification/TestApiConsistency.cs b/src/Lucene.Net.Tests.Classification/TestApiConsistency.cs
new file mode 100644
index 0000000..05c7f76
--- /dev/null
+++ b/src/Lucene.Net.Tests.Classification/TestApiConsistency.cs
@@ -0,0 +1,120 @@
+\ufeffusing Lucene.Net.Attributes;
+using Lucene.Net.Util;
+using NUnit.Framework;
+using System;
+
+namespace Lucene.Net.Classification
+{
+ /// <summary>
+ /// LUCENENET specific tests for ensuring API conventions are followed
+ /// </summary>
+ public class TestApiConsistency : ApiScanTestBase
+ {
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Classification.KNearestNeighborClassifier))]
+ public override void TestProtectedFieldNames(Type typeFromTargetAssembly)
+ {
+ base.TestProtectedFieldNames(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Classification.KNearestNeighborClassifier))]
+ public override void TestPrivateFieldNames(Type typeFromTargetAssembly)
+ {
+ base.TestPrivateFieldNames(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Classification.KNearestNeighborClassifier))]
+ public override void TestPublicFields(Type typeFromTargetAssembly)
+ {
+ base.TestPublicFields(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Classification.KNearestNeighborClassifier))]
+ public override void TestMethodParameterNames(Type typeFromTargetAssembly)
+ {
+ base.TestMethodParameterNames(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Classification.KNearestNeighborClassifier))]
+ public override void TestInterfaceNames(Type typeFromTargetAssembly)
+ {
+ base.TestInterfaceNames(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Classification.KNearestNeighborClassifier))]
+ public override void TestClassNames(Type typeFromTargetAssembly)
+ {
+ base.TestClassNames(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Classification.KNearestNeighborClassifier))]
+ public override void TestForPropertiesWithNoGetter(Type typeFromTargetAssembly)
+ {
+ base.TestForPropertiesWithNoGetter(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Classification.KNearestNeighborClassifier))]
+ public override void TestForPropertiesThatReturnArray(Type typeFromTargetAssembly)
+ {
+ base.TestForPropertiesThatReturnArray(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Classification.KNearestNeighborClassifier))]
+ public override void TestForMethodsThatReturnWritableArray(Type typeFromTargetAssembly)
+ {
+ base.TestForMethodsThatReturnWritableArray(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Classification.KNearestNeighborClassifier))]
+ public override void TestForPublicMembersContainingComparer(Type typeFromTargetAssembly)
+ {
+ base.TestForPublicMembersContainingComparer(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Classification.KNearestNeighborClassifier))]
+ public override void TestForPublicMembersNamedSize(Type typeFromTargetAssembly)
+ {
+ base.TestForPublicMembersNamedSize(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Classification.KNearestNeighborClassifier))]
+ public override void TestForPublicMembersContainingNonNetNumeric(Type typeFromTargetAssembly)
+ {
+ base.TestForPublicMembersContainingNonNetNumeric(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Classification.KNearestNeighborClassifier))]
+ public override void TestForPublicMembersWithNullableEnum(Type typeFromTargetAssembly)
+ {
+ base.TestForPublicMembersWithNullableEnum(typeFromTargetAssembly);
+ }
+
+ // LUCENENET NOTE: This test is only for identifying members who were changed from
+ // ICollection, IList or ISet to IEnumerable during the port (that should be changed back)
+ //[Test, LuceneNetSpecific]
+ //[TestCase(typeof(Lucene.Net.Classification.KNearestNeighborClassifier))]
+ //public override void TestForMembersAcceptingOrReturningIEnumerable(Type typeFromTargetAssembly)
+ //{
+ // base.TestForMembersAcceptingOrReturningIEnumerable(typeFromTargetAssembly);
+ //}
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Classification.KNearestNeighborClassifier))]
+ public override void TestForMembersAcceptingOrReturningListOrDictionary(Type typeFromTargetAssembly)
+ {
+ base.TestForMembersAcceptingOrReturningListOrDictionary(typeFromTargetAssembly);
+ }
+ }
+}
[05/28] lucenenet git commit:
Lucene.Net.Misc.Util.Fst.UpToTwoPositiveIntOutputs refactor: renamed method
parameters camelCase
Posted by ni...@apache.org.
Lucene.Net.Misc.Util.Fst.UpToTwoPositiveIntOutputs refactor: renamed method parameters camelCase
Project: http://git-wip-us.apache.org/repos/asf/lucenenet/repo
Commit: http://git-wip-us.apache.org/repos/asf/lucenenet/commit/366eb42d
Tree: http://git-wip-us.apache.org/repos/asf/lucenenet/tree/366eb42d
Diff: http://git-wip-us.apache.org/repos/asf/lucenenet/diff/366eb42d
Branch: refs/heads/api-work
Commit: 366eb42da9e9c61e65a5f8492df549a8e429aa20
Parents: 30f9959
Author: Shad Storhaug <sh...@shadstorhaug.com>
Authored: Wed Feb 1 13:33:19 2017 +0700
Committer: Shad Storhaug <sh...@shadstorhaug.com>
Committed: Wed Feb 1 13:33:19 2017 +0700
----------------------------------------------------------------------
.../Util/Fst/UpToTwoPositiveIntOutputs.cs | 104 +++++++++----------
1 file changed, 52 insertions(+), 52 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/366eb42d/src/Lucene.Net.Misc/Util/Fst/UpToTwoPositiveIntOutputs.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Misc/Util/Fst/UpToTwoPositiveIntOutputs.cs b/src/Lucene.Net.Misc/Util/Fst/UpToTwoPositiveIntOutputs.cs
index cf3596e..8378f20 100644
--- a/src/Lucene.Net.Misc/Util/Fst/UpToTwoPositiveIntOutputs.cs
+++ b/src/Lucene.Net.Misc/Util/Fst/UpToTwoPositiveIntOutputs.cs
@@ -79,12 +79,12 @@ namespace Lucene.Net.Util.Fst
return "TwoLongs:" + first + "," + second;
}
- public override bool Equals(object _other)
+ public override bool Equals(object other)
{
- if (_other is TwoLongs)
+ if (other is TwoLongs)
{
- TwoLongs other = (TwoLongs)_other;
- return first == other.first && second == other.second;
+ TwoLongs other2 = (TwoLongs)other;
+ return first == other2.first && second == other2.second;
}
else
{
@@ -132,25 +132,25 @@ namespace Lucene.Net.Util.Fst
return new TwoLongs(first, second);
}
- public override object Common(object _output1, object _output2)
+ public override object Common(object output1, object output2)
{
- Debug.Assert(Valid(_output1, false));
- Debug.Assert(Valid(_output2, false));
- long? output1 = (long?)_output1;
- long? output2 = (long?)_output2;
- if (output1 == NO_OUTPUT || output2 == NO_OUTPUT)
+ Debug.Assert(Valid(output1, false));
+ Debug.Assert(Valid(output2, false));
+ long? output1_ = (long?)output1;
+ long? output2_ = (long?)output2;
+ if (output1_ == NO_OUTPUT || output2_ == NO_OUTPUT)
{
return NO_OUTPUT;
}
else if (doShare)
{
- Debug.Assert(output1 > 0);
- Debug.Assert(output2 > 0);
- return Math.Min(output1.GetValueOrDefault(), output2.GetValueOrDefault());
+ Debug.Assert(output1_ > 0);
+ Debug.Assert(output2_ > 0);
+ return Math.Min(output1_.GetValueOrDefault(), output2_.GetValueOrDefault());
}
- else if (output1.Equals(output2))
+ else if (output1_.Equals(output2_))
{
- return output1;
+ return output1_;
}
else
{
@@ -158,70 +158,70 @@ namespace Lucene.Net.Util.Fst
}
}
- public override object Subtract(object _output, object _inc)
+ public override object Subtract(object output, object inc)
{
- Debug.Assert(Valid(_output, false));
- Debug.Assert(Valid(_inc, false));
- long? output = (long?)_output;
- long? inc = (long?)_inc;
- Debug.Assert(output >= inc);
+ Debug.Assert(Valid(output, false));
+ Debug.Assert(Valid(inc, false));
+ long? output2 = (long?)output;
+ long? inc2 = (long?)inc;
+ Debug.Assert(output2 >= inc2);
- if (inc == NO_OUTPUT)
+ if (inc2 == NO_OUTPUT)
{
- return output;
+ return output2;
}
- else if (output.Equals(inc))
+ else if (output2.Equals(inc2))
{
return NO_OUTPUT;
}
else
{
- return output - inc;
+ return output2 - inc2;
}
}
- public override object Add(object _prefix, object _output)
+ public override object Add(object prefix, object output)
{
- Debug.Assert(Valid(_prefix, false));
- Debug.Assert(Valid(_output, true));
- long? prefix = (long?)_prefix;
- if (_output is long?)
+ Debug.Assert(Valid(prefix, false));
+ Debug.Assert(Valid(output, true));
+ long? prefix2 = (long?)prefix;
+ if (output is long?)
{
- long? output = (long?)_output;
- if (prefix == NO_OUTPUT)
+ long? output2 = (long?)output;
+ if (prefix2 == NO_OUTPUT)
{
- return output;
+ return output2;
}
- else if (output == NO_OUTPUT)
+ else if (output2 == NO_OUTPUT)
{
- return prefix;
+ return prefix2;
}
else
{
- return prefix + output;
+ return prefix2 + output2;
}
}
else
{
- TwoLongs output = (TwoLongs)_output;
- long v = prefix.Value;
- return new TwoLongs(output.First + v, output.Second + v);
+ TwoLongs output3 = (TwoLongs)output;
+ long v = prefix2.Value;
+ return new TwoLongs(output3.First + v, output3.Second + v);
}
}
- public override void Write(object _output, DataOutput @out)
+ public override void Write(object output, DataOutput @out)
{
- Debug.Assert(Valid(_output, true));
- if (_output is long?)
+ Debug.Assert(Valid(output, true));
+ if (output is long?)
{
- long? output = (long?)_output;
- @out.WriteVLong(output.GetValueOrDefault() << 1);
+ long? output2 = (long?)output;
+ @out.WriteVLong(output2.GetValueOrDefault() << 1);
}
else
{
- TwoLongs output = (TwoLongs)_output;
- @out.WriteVLong((output.First << 1) | 1);
- @out.WriteVLong(output.Second);
+ TwoLongs output3 = (TwoLongs)output;
+ @out.WriteVLong((output3.First << 1) | 1);
+ @out.WriteVLong(output3.Second);
}
}
@@ -259,20 +259,20 @@ namespace Lucene.Net.Util.Fst
}
// Used only by assert
- private bool Valid(object _o, bool allowDouble)
+ private bool Valid(object o, bool allowDouble)
{
if (!allowDouble)
{
- Debug.Assert(_o is long?);
- return Valid((long?)_o);
+ Debug.Assert(o is long?);
+ return Valid((long?)o);
}
- else if (_o is TwoLongs)
+ else if (o is TwoLongs)
{
return true;
}
else
{
- return Valid((long?)_o);
+ return Valid((long?)o);
}
}
[17/28] lucenenet git commit: Lucene.Net.Grouping: added
WritableArray and SuppressMessage attribute to public array properties
Posted by ni...@apache.org.
Lucene.Net.Grouping: added WritableArray and SuppressMessage attribute to public array properties
Project: http://git-wip-us.apache.org/repos/asf/lucenenet/repo
Commit: http://git-wip-us.apache.org/repos/asf/lucenenet/commit/1dccd774
Tree: http://git-wip-us.apache.org/repos/asf/lucenenet/tree/1dccd774
Diff: http://git-wip-us.apache.org/repos/asf/lucenenet/diff/1dccd774
Branch: refs/heads/api-work
Commit: 1dccd77405a0d567790009734651d047ffa72b1f
Parents: d604cab
Author: Shad Storhaug <sh...@shadstorhaug.com>
Authored: Wed Feb 1 14:26:32 2017 +0700
Committer: Shad Storhaug <sh...@shadstorhaug.com>
Committed: Wed Feb 1 14:26:32 2017 +0700
----------------------------------------------------------------------
src/Lucene.Net.Grouping/GroupDocs.cs | 8 +++++++-
src/Lucene.Net.Grouping/SearchGroup.cs | 3 +++
src/Lucene.Net.Grouping/TopGroups.cs | 10 +++++++++-
3 files changed, 19 insertions(+), 2 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/1dccd774/src/Lucene.Net.Grouping/GroupDocs.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Grouping/GroupDocs.cs b/src/Lucene.Net.Grouping/GroupDocs.cs
index c997e30..34c2ccd 100644
--- a/src/Lucene.Net.Grouping/GroupDocs.cs
+++ b/src/Lucene.Net.Grouping/GroupDocs.cs
@@ -1,4 +1,5 @@
-\ufeffusing Lucene.Net.Search;
+\ufeffusing Lucene.Net.Support;
+using System.Diagnostics.CodeAnalysis;
namespace Lucene.Net.Search.Grouping
{
@@ -46,6 +47,8 @@ namespace Lucene.Net.Search.Grouping
/// Hits; this may be <see cref="FieldDoc"/> instances if the
/// withinGroupSort sorted by fields.
/// </summary>
+ [WritableArray]
+ [SuppressMessage("Microsoft.Performance", "CA1819", Justification = "Lucene's design requires some writable array properties")]
public ScoreDoc[] ScoreDocs { get; private set; }
/// <summary>
@@ -56,6 +59,8 @@ namespace Lucene.Net.Search.Grouping
/// <summary>
/// Matches the groupSort passed to <see cref="AbstractFirstPassGroupingCollector{TGroupValue}"/>.
/// </summary>
+ [WritableArray]
+ [SuppressMessage("Microsoft.Performance", "CA1819", Justification = "Lucene's design requires some writable array properties")]
public object[] GroupSortValues { get; private set; }
public GroupDocs(float score, float maxScore, int totalHits, ScoreDoc[] scoreDocs, TGroupValue groupValue, object[] groupSortValues)
@@ -96,6 +101,7 @@ namespace Lucene.Net.Search.Grouping
/// Hits; this may be <see cref="FieldDoc"/> instances if the
/// withinGroupSort sorted by fields.
/// </summary>
+ [SuppressMessage("Microsoft.Performance", "CA1819", Justification = "Lucene's design requires some writable array properties")]
ScoreDoc[] ScoreDocs { get; }
/// <summary>
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/1dccd774/src/Lucene.Net.Grouping/SearchGroup.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Grouping/SearchGroup.cs b/src/Lucene.Net.Grouping/SearchGroup.cs
index 565ab15..cad33f3 100644
--- a/src/Lucene.Net.Grouping/SearchGroup.cs
+++ b/src/Lucene.Net.Grouping/SearchGroup.cs
@@ -2,6 +2,7 @@
using System;
using System.Collections.Generic;
using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
using System.Linq;
namespace Lucene.Net.Search.Grouping
@@ -43,6 +44,8 @@ namespace Lucene.Net.Search.Grouping
/// <c>null</c> if <c>fillFields=false</c> had
/// been passed to <see cref="AbstractFirstPassGroupingCollector{TGroupValue}.GetTopGroups(int, bool)"/>
/// </summary>
+ [WritableArray]
+ [SuppressMessage("Microsoft.Performance", "CA1819", Justification = "Lucene's design requires some writable array properties")]
public object[] SortValues { get; set; }
public override string ToString()
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/1dccd774/src/Lucene.Net.Grouping/TopGroups.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Grouping/TopGroups.cs b/src/Lucene.Net.Grouping/TopGroups.cs
index d8a2165..132957c 100644
--- a/src/Lucene.Net.Grouping/TopGroups.cs
+++ b/src/Lucene.Net.Grouping/TopGroups.cs
@@ -1,4 +1,6 @@
-\ufeffusing System;
+\ufeffusing Lucene.Net.Support;
+using System;
+using System.Diagnostics.CodeAnalysis;
namespace Lucene.Net.Search.Grouping
{
@@ -40,14 +42,20 @@ namespace Lucene.Net.Search.Grouping
/// <summary>
/// Group results in groupSort order </summary>
+ [WritableArray]
+ [SuppressMessage("Microsoft.Performance", "CA1819", Justification = "Lucene's design requires some writable array properties")]
public IGroupDocs<TGroupValue>[] Groups { get; private set; }
/// <summary>
/// How groups are sorted against each other </summary>
+ [WritableArray]
+ [SuppressMessage("Microsoft.Performance", "CA1819", Justification = "Lucene's design requires some writable array properties")]
public SortField[] GroupSort { get; private set; }
/// <summary>
/// How docs are sorted within each group </summary>
+ [WritableArray]
+ [SuppressMessage("Microsoft.Performance", "CA1819", Justification = "Lucene's design requires some writable array properties")]
public SortField[] WithinGroupSort { get; private set; }
/// <summary>
[02/28] lucenenet git commit:
Lucene.Net.Misc.Index.Sorter.SortingMergePolicy.Info: added getter to prevent
the test from failing.
Posted by ni...@apache.org.
Lucene.Net.Misc.Index.Sorter.SortingMergePolicy.Info: added getter to prevent the test from failing.
Project: http://git-wip-us.apache.org/repos/asf/lucenenet/repo
Commit: http://git-wip-us.apache.org/repos/asf/lucenenet/commit/754202c3
Tree: http://git-wip-us.apache.org/repos/asf/lucenenet/tree/754202c3
Diff: http://git-wip-us.apache.org/repos/asf/lucenenet/diff/754202c3
Branch: refs/heads/api-work
Commit: 754202c35d61f1d0c63f6a66924ba7e4c8faf648
Parents: 681a70f
Author: Shad Storhaug <sh...@shadstorhaug.com>
Authored: Wed Feb 1 13:12:17 2017 +0700
Committer: Shad Storhaug <sh...@shadstorhaug.com>
Committed: Wed Feb 1 13:12:17 2017 +0700
----------------------------------------------------------------------
src/Lucene.Net.Misc/Index/Sorter/SortingMergePolicy.cs | 4 ++++
1 file changed, 4 insertions(+)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/754202c3/src/Lucene.Net.Misc/Index/Sorter/SortingMergePolicy.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Misc/Index/Sorter/SortingMergePolicy.cs b/src/Lucene.Net.Misc/Index/Sorter/SortingMergePolicy.cs
index 1175576..dd3eb7d 100644
--- a/src/Lucene.Net.Misc/Index/Sorter/SortingMergePolicy.cs
+++ b/src/Lucene.Net.Misc/Index/Sorter/SortingMergePolicy.cs
@@ -91,6 +91,10 @@ namespace Lucene.Net.Index.Sorter
public override SegmentCommitInfo Info
{
+ get // LUCENENET specific: added getter
+ {
+ return base.info;
+ }
set
{
IDictionary<string, string> diagnostics = value.Info.Diagnostics;
[13/28] lucenenet git commit:
Lucene.Net.Highlighter.VectorHighlight.FieldFragList refactor: changed
parameter and return types from List to IList
Posted by ni...@apache.org.
Lucene.Net.Highlighter.VectorHighlight.FieldFragList refactor: changed parameter and return types from List<T> to IList<T>
Project: http://git-wip-us.apache.org/repos/asf/lucenenet/repo
Commit: http://git-wip-us.apache.org/repos/asf/lucenenet/commit/a755a13f
Tree: http://git-wip-us.apache.org/repos/asf/lucenenet/tree/a755a13f
Diff: http://git-wip-us.apache.org/repos/asf/lucenenet/diff/a755a13f
Branch: refs/heads/api-work
Commit: a755a13f18e5b98d3347a6e2e09318aa51f8c97b
Parents: 8706ebb
Author: Shad Storhaug <sh...@shadstorhaug.com>
Authored: Wed Feb 1 14:07:33 2017 +0700
Committer: Shad Storhaug <sh...@shadstorhaug.com>
Committed: Wed Feb 1 14:07:33 2017 +0700
----------------------------------------------------------------------
src/Lucene.Net.Highlighter/VectorHighlight/FieldFragList.cs | 6 +++---
1 file changed, 3 insertions(+), 3 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/a755a13f/src/Lucene.Net.Highlighter/VectorHighlight/FieldFragList.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Highlighter/VectorHighlight/FieldFragList.cs b/src/Lucene.Net.Highlighter/VectorHighlight/FieldFragList.cs
index 8ca9341..5d7f44b 100644
--- a/src/Lucene.Net.Highlighter/VectorHighlight/FieldFragList.cs
+++ b/src/Lucene.Net.Highlighter/VectorHighlight/FieldFragList.cs
@@ -60,12 +60,12 @@ namespace Lucene.Net.Search.VectorHighlight
/// </summary>
public class WeightedFragInfo
{
- private List<SubInfo> subInfos;
+ private IList<SubInfo> subInfos;
private float totalBoost;
private int startOffset;
private int endOffset;
- public WeightedFragInfo(int startOffset, int endOffset, List<SubInfo> subInfos, float totalBoost)
+ public WeightedFragInfo(int startOffset, int endOffset, IList<SubInfo> subInfos, float totalBoost)
{
this.startOffset = startOffset;
this.endOffset = endOffset;
@@ -73,7 +73,7 @@ namespace Lucene.Net.Search.VectorHighlight
this.subInfos = subInfos;
}
- public List<SubInfo> SubInfos
+ public IList<SubInfo> SubInfos
{
get { return subInfos; }
}
[09/28] lucenenet git commit:
Lucene.Net.Memory.MemoryIndex.MemoryIndexReader.Searcher: added getter per
MSDN guidelines
Posted by ni...@apache.org.
Lucene.Net.Memory.MemoryIndex.MemoryIndexReader.Searcher: added getter per MSDN guidelines
Project: http://git-wip-us.apache.org/repos/asf/lucenenet/repo
Commit: http://git-wip-us.apache.org/repos/asf/lucenenet/commit/8ddd86b0
Tree: http://git-wip-us.apache.org/repos/asf/lucenenet/tree/8ddd86b0
Diff: http://git-wip-us.apache.org/repos/asf/lucenenet/diff/8ddd86b0
Branch: refs/heads/api-work
Commit: 8ddd86b0dcbec489248e87911dea846e90275e3b
Parents: 9ccf3f0
Author: Shad Storhaug <sh...@shadstorhaug.com>
Authored: Wed Feb 1 13:49:23 2017 +0700
Committer: Shad Storhaug <sh...@shadstorhaug.com>
Committed: Wed Feb 1 13:49:23 2017 +0700
----------------------------------------------------------------------
src/Lucene.Net.Memory/MemoryIndex.MemoryIndexReader.cs | 4 ++++
1 file changed, 4 insertions(+)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8ddd86b0/src/Lucene.Net.Memory/MemoryIndex.MemoryIndexReader.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Memory/MemoryIndex.MemoryIndexReader.cs b/src/Lucene.Net.Memory/MemoryIndex.MemoryIndexReader.cs
index 9e70d6e..b6ba603 100644
--- a/src/Lucene.Net.Memory/MemoryIndex.MemoryIndexReader.cs
+++ b/src/Lucene.Net.Memory/MemoryIndex.MemoryIndexReader.cs
@@ -594,6 +594,10 @@ namespace Lucene.Net.Index.Memory
internal IndexSearcher Searcher
{
+ get // LUCENENET specific: added getter per MSDN guidelines
+ {
+ return this.searcher;
+ }
set
{
this.searcher = value;
[14/28] lucenenet git commit: Lucene.Net.Tests.Grouping: added API
consistency tests
Posted by ni...@apache.org.
Lucene.Net.Tests.Grouping: added API consistency tests
Project: http://git-wip-us.apache.org/repos/asf/lucenenet/repo
Commit: http://git-wip-us.apache.org/repos/asf/lucenenet/commit/8667326d
Tree: http://git-wip-us.apache.org/repos/asf/lucenenet/tree/8667326d
Diff: http://git-wip-us.apache.org/repos/asf/lucenenet/diff/8667326d
Branch: refs/heads/api-work
Commit: 8667326dec53a0507902044417ce68ae4b1264b2
Parents: a755a13
Author: Shad Storhaug <sh...@shadstorhaug.com>
Authored: Wed Feb 1 14:11:09 2017 +0700
Committer: Shad Storhaug <sh...@shadstorhaug.com>
Committed: Wed Feb 1 14:11:09 2017 +0700
----------------------------------------------------------------------
.../Lucene.Net.Tests.Grouping.csproj | 1 +
.../TestApiConsistency.cs | 120 +++++++++++++++++++
2 files changed, 121 insertions(+)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8667326d/src/Lucene.Net.Tests.Grouping/Lucene.Net.Tests.Grouping.csproj
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Grouping/Lucene.Net.Tests.Grouping.csproj b/src/Lucene.Net.Tests.Grouping/Lucene.Net.Tests.Grouping.csproj
index 5551b2b..69674b5 100644
--- a/src/Lucene.Net.Tests.Grouping/Lucene.Net.Tests.Grouping.csproj
+++ b/src/Lucene.Net.Tests.Grouping/Lucene.Net.Tests.Grouping.csproj
@@ -47,6 +47,7 @@
<Compile Include="GroupFacetCollectorTest.cs" />
<Compile Include="GroupingSearchTest.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />
+ <Compile Include="TestApiConsistency.cs" />
<Compile Include="TestGrouping.cs" />
</ItemGroup>
<ItemGroup>
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8667326d/src/Lucene.Net.Tests.Grouping/TestApiConsistency.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Grouping/TestApiConsistency.cs b/src/Lucene.Net.Tests.Grouping/TestApiConsistency.cs
new file mode 100644
index 0000000..566834d
--- /dev/null
+++ b/src/Lucene.Net.Tests.Grouping/TestApiConsistency.cs
@@ -0,0 +1,120 @@
+\ufeffusing Lucene.Net.Attributes;
+using Lucene.Net.Util;
+using NUnit.Framework;
+using System;
+
+namespace Lucene.Net.Tests.Grouping
+{
+ /// <summary>
+ /// LUCENENET specific tests for ensuring API conventions are followed
+ /// </summary>
+ public class TestApiConsistency : ApiScanTestBase
+ {
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Search.Grouping.ICollectedSearchGroup))]
+ public override void TestProtectedFieldNames(Type typeFromTargetAssembly)
+ {
+ base.TestProtectedFieldNames(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Search.Grouping.ICollectedSearchGroup))]
+ public override void TestPrivateFieldNames(Type typeFromTargetAssembly)
+ {
+ base.TestPrivateFieldNames(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Search.Grouping.ICollectedSearchGroup))]
+ public override void TestPublicFields(Type typeFromTargetAssembly)
+ {
+ base.TestPublicFields(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Search.Grouping.ICollectedSearchGroup))]
+ public override void TestMethodParameterNames(Type typeFromTargetAssembly)
+ {
+ base.TestMethodParameterNames(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Search.Grouping.ICollectedSearchGroup))]
+ public override void TestInterfaceNames(Type typeFromTargetAssembly)
+ {
+ base.TestInterfaceNames(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Search.Grouping.ICollectedSearchGroup))]
+ public override void TestClassNames(Type typeFromTargetAssembly)
+ {
+ base.TestClassNames(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Search.Grouping.ICollectedSearchGroup))]
+ public override void TestForPropertiesWithNoGetter(Type typeFromTargetAssembly)
+ {
+ base.TestForPropertiesWithNoGetter(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Search.Grouping.ICollectedSearchGroup))]
+ public override void TestForPropertiesThatReturnArray(Type typeFromTargetAssembly)
+ {
+ base.TestForPropertiesThatReturnArray(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Search.Grouping.ICollectedSearchGroup))]
+ public override void TestForMethodsThatReturnWritableArray(Type typeFromTargetAssembly)
+ {
+ base.TestForMethodsThatReturnWritableArray(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Search.Grouping.ICollectedSearchGroup))]
+ public override void TestForPublicMembersContainingComparer(Type typeFromTargetAssembly)
+ {
+ base.TestForPublicMembersContainingComparer(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Search.Grouping.ICollectedSearchGroup))]
+ public override void TestForPublicMembersNamedSize(Type typeFromTargetAssembly)
+ {
+ base.TestForPublicMembersNamedSize(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Search.Grouping.ICollectedSearchGroup))]
+ public override void TestForPublicMembersContainingNonNetNumeric(Type typeFromTargetAssembly)
+ {
+ base.TestForPublicMembersContainingNonNetNumeric(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Search.Grouping.ICollectedSearchGroup))]
+ public override void TestForPublicMembersWithNullableEnum(Type typeFromTargetAssembly)
+ {
+ base.TestForPublicMembersWithNullableEnum(typeFromTargetAssembly);
+ }
+
+ // LUCENENET NOTE: This test is only for identifying members who were changed from
+ // ICollection, IList or ISet to IEnumerable during the port (that should be changed back)
+ //[Test, LuceneNetSpecific]
+ //[TestCase(typeof(Lucene.Net.Search.Grouping.ICollectedSearchGroup))]
+ //public override void TestForMembersAcceptingOrReturningIEnumerable(Type typeFromTargetAssembly)
+ //{
+ // base.TestForMembersAcceptingOrReturningIEnumerable(typeFromTargetAssembly);
+ //}
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Search.Grouping.ICollectedSearchGroup))]
+ public override void TestForMembersAcceptingOrReturningListOrDictionary(Type typeFromTargetAssembly)
+ {
+ base.TestForMembersAcceptingOrReturningListOrDictionary(typeFromTargetAssembly);
+ }
+ }
+}
[25/28] lucenenet git commit:
Lucene.Net.Analysis.Stempel.Egothor.Stemmer.MultiTrie: renamed protected
field tries > m_tries
Posted by ni...@apache.org.
Lucene.Net.Analysis.Stempel.Egothor.Stemmer.MultiTrie: renamed protected field tries > m_tries
Project: http://git-wip-us.apache.org/repos/asf/lucenenet/repo
Commit: http://git-wip-us.apache.org/repos/asf/lucenenet/commit/87f05e95
Tree: http://git-wip-us.apache.org/repos/asf/lucenenet/tree/87f05e95
Diff: http://git-wip-us.apache.org/repos/asf/lucenenet/diff/87f05e95
Branch: refs/heads/api-work
Commit: 87f05e955a2be2a5b8a379246f36e51032e634eb
Parents: 2eef6df
Author: Shad Storhaug <sh...@shadstorhaug.com>
Authored: Wed Feb 1 17:06:27 2017 +0700
Committer: Shad Storhaug <sh...@shadstorhaug.com>
Committed: Wed Feb 1 17:06:27 2017 +0700
----------------------------------------------------------------------
.../Egothor.Stemmer/MultiTrie.cs | 34 ++++++++++----------
.../Egothor.Stemmer/MultiTrie2.cs | 32 +++++++++---------
2 files changed, 33 insertions(+), 33 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/87f05e95/src/Lucene.Net.Analysis.Stempel/Egothor.Stemmer/MultiTrie.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Analysis.Stempel/Egothor.Stemmer/MultiTrie.cs b/src/Lucene.Net.Analysis.Stempel/Egothor.Stemmer/MultiTrie.cs
index 7bdad8f..d8a3282 100644
--- a/src/Lucene.Net.Analysis.Stempel/Egothor.Stemmer/MultiTrie.cs
+++ b/src/Lucene.Net.Analysis.Stempel/Egothor.Stemmer/MultiTrie.cs
@@ -70,7 +70,7 @@ namespace Egothor.Stemmer
internal static char EOM = '*';
internal static string EOM_NODE = "" + EOM;
- protected List<Trie> tries = new List<Trie>();
+ protected List<Trie> m_tries = new List<Trie>();
int BY = 1;
@@ -86,7 +86,7 @@ namespace Egothor.Stemmer
BY = @is.ReadInt();
for (int i = @is.ReadInt(); i > 0; i--)
{
- tries.Add(new Trie(@is));
+ m_tries.Add(new Trie(@is));
}
}
@@ -106,10 +106,10 @@ namespace Egothor.Stemmer
/// <returns>the element</returns>
public override string GetFully(string key)
{
- StringBuilder result = new StringBuilder(tries.Count * 2);
- for (int i = 0; i < tries.Count; i++)
+ StringBuilder result = new StringBuilder(m_tries.Count * 2);
+ for (int i = 0; i < m_tries.Count; i++)
{
- string r = tries[i].GetFully(key);
+ string r = m_tries[i].GetFully(key);
if (r == null || (r.Length == 1 && r[0] == EOM))
{
return result.ToString();
@@ -127,10 +127,10 @@ namespace Egothor.Stemmer
/// <returns>the element that is stored as last on a path</returns>
public override string GetLastOnPath(string key)
{
- StringBuilder result = new StringBuilder(tries.Count * 2);
- for (int i = 0; i < tries.Count; i++)
+ StringBuilder result = new StringBuilder(m_tries.Count * 2);
+ for (int i = 0; i < m_tries.Count; i++)
{
- string r = tries[i].GetLastOnPath(key);
+ string r = m_tries[i].GetLastOnPath(key);
if (r == null || (r.Length == 1 && r[0] == EOM))
{
return result.ToString();
@@ -149,8 +149,8 @@ namespace Egothor.Stemmer
{
os.WriteBoolean(forward);
os.WriteInt(BY);
- os.WriteInt(tries.Count);
- foreach (Trie trie in tries)
+ os.WriteInt(m_tries.Count);
+ foreach (Trie trie in m_tries)
trie.Store(os);
}
@@ -171,15 +171,15 @@ namespace Egothor.Stemmer
return;
}
int levels = cmd.Length / BY;
- while (levels >= tries.Count)
+ while (levels >= m_tries.Count)
{
- tries.Add(new Trie(forward));
+ m_tries.Add(new Trie(forward));
}
for (int i = 0; i < levels; i++)
{
- tries[i].Add(key, cmd.Substring(BY * i, BY));
+ m_tries[i].Add(key, cmd.Substring(BY * i, BY));
}
- tries[levels].Add(key, EOM_NODE);
+ m_tries[levels].Add(key, EOM_NODE);
}
/// <summary>
@@ -190,11 +190,11 @@ namespace Egothor.Stemmer
public override Trie Reduce(Reduce by)
{
List<Trie> h = new List<Trie>();
- foreach (Trie trie in tries)
+ foreach (Trie trie in m_tries)
h.Add(trie.Reduce(by));
MultiTrie m = new MultiTrie(forward);
- m.tries = h;
+ m.m_tries = h;
return m;
}
@@ -206,7 +206,7 @@ namespace Egothor.Stemmer
public override void PrintInfo(TextWriter @out, string prefix)
{
int c = 0;
- foreach (Trie trie in tries)
+ foreach (Trie trie in m_tries)
trie.PrintInfo(@out, prefix + "[" + (++c) + "] ");
}
}
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/87f05e95/src/Lucene.Net.Analysis.Stempel/Egothor.Stemmer/MultiTrie2.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Analysis.Stempel/Egothor.Stemmer/MultiTrie2.cs b/src/Lucene.Net.Analysis.Stempel/Egothor.Stemmer/MultiTrie2.cs
index 9db6b92..cc6dbed 100644
--- a/src/Lucene.Net.Analysis.Stempel/Egothor.Stemmer/MultiTrie2.cs
+++ b/src/Lucene.Net.Analysis.Stempel/Egothor.Stemmer/MultiTrie2.cs
@@ -96,15 +96,15 @@ namespace Egothor.Stemmer
/// <returns>the element</returns>
public override string GetFully(string key)
{
- StringBuilder result = new StringBuilder(tries.Count * 2);
+ StringBuilder result = new StringBuilder(m_tries.Count * 2);
try
{
string lastkey = key;
- string[] p = new string[tries.Count];
+ string[] p = new string[m_tries.Count];
char lastch = ' ';
- for (int i = 0; i < tries.Count; i++)
+ for (int i = 0; i < m_tries.Count; i++)
{
- string r = tries[i].GetFully(lastkey);
+ string r = m_tries[i].GetFully(lastkey);
if (r == null || (r.Length == 1 && r[0] == EOM))
{
return result.ToString();
@@ -153,15 +153,15 @@ namespace Egothor.Stemmer
/// <returns>the element that is stored as last on a path</returns>
public override string GetLastOnPath(string key)
{
- StringBuilder result = new StringBuilder(tries.Count * 2);
+ StringBuilder result = new StringBuilder(m_tries.Count * 2);
try
{
string lastkey = key;
- string[] p = new string[tries.Count];
+ string[] p = new string[m_tries.Count];
char lastch = ' ';
- for (int i = 0; i < tries.Count; i++)
+ for (int i = 0; i < m_tries.Count; i++)
{
- string r = tries[i].GetLastOnPath(lastkey);
+ string r = m_tries[i].GetLastOnPath(lastkey);
if (r == null || (r.Length == 1 && r[0] == EOM))
{
return result.ToString();
@@ -233,21 +233,21 @@ namespace Egothor.Stemmer
string[] p = Decompose(cmd);
int levels = p.Length;
// System.err.println("levels "+key+" cmd "+cmd+"|"+levels);
- while (levels >= tries.Count)
+ while (levels >= m_tries.Count)
{
- tries.Add(new Trie(forward));
+ m_tries.Add(new Trie(forward));
}
string lastkey = key;
for (int i = 0; i < levels; i++)
{
if (key.Length > 0)
{
- tries[i].Add(key, p[i]);
+ m_tries[i].Add(key, p[i]);
lastkey = key;
}
else
{
- tries[i].Add(lastkey, p[i]);
+ m_tries[i].Add(lastkey, p[i]);
}
// System.err.println("-"+key+" "+p[i]+"|"+key.length());
/*
@@ -277,11 +277,11 @@ namespace Egothor.Stemmer
}
if (key.Length > 0)
{
- tries[levels].Add(key, EOM_NODE);
+ m_tries[levels].Add(key, EOM_NODE);
}
else
{
- tries[levels].Add(lastkey, EOM_NODE);
+ m_tries[levels].Add(lastkey, EOM_NODE);
}
}
@@ -338,11 +338,11 @@ namespace Egothor.Stemmer
public override Trie Reduce(Reduce by)
{
List<Trie> h = new List<Trie>();
- foreach (Trie trie in tries)
+ foreach (Trie trie in m_tries)
h.Add(trie.Reduce(by));
MultiTrie2 m = new MultiTrie2(forward);
- m.tries = h;
+ m.m_tries = h;
return m;
}
[07/28] lucenenet git commit:
Lucene.Net.Misc.Index.Sorter.SortingMergePolicy: removed TODO about changing
mergeTrigger parameter to non-nullable,
since we already have a test as a reminder.
Posted by ni...@apache.org.
Lucene.Net.Misc.Index.Sorter.SortingMergePolicy: removed TODO about changing mergeTrigger parameter to non-nullable, since we already have a test as a reminder.
Project: http://git-wip-us.apache.org/repos/asf/lucenenet/repo
Commit: http://git-wip-us.apache.org/repos/asf/lucenenet/commit/a7dae6eb
Tree: http://git-wip-us.apache.org/repos/asf/lucenenet/tree/a7dae6eb
Diff: http://git-wip-us.apache.org/repos/asf/lucenenet/diff/a7dae6eb
Branch: refs/heads/api-work
Commit: a7dae6eb3dde336ee35b799f02f8970925a90ff8
Parents: 375e3b6
Author: Shad Storhaug <sh...@shadstorhaug.com>
Authored: Wed Feb 1 13:43:41 2017 +0700
Committer: Shad Storhaug <sh...@shadstorhaug.com>
Committed: Wed Feb 1 13:43:41 2017 +0700
----------------------------------------------------------------------
src/Lucene.Net.Misc/Index/Sorter/SortingMergePolicy.cs | 1 -
1 file changed, 1 deletion(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/a7dae6eb/src/Lucene.Net.Misc/Index/Sorter/SortingMergePolicy.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Misc/Index/Sorter/SortingMergePolicy.cs b/src/Lucene.Net.Misc/Index/Sorter/SortingMergePolicy.cs
index dd3eb7d..168be09 100644
--- a/src/Lucene.Net.Misc/Index/Sorter/SortingMergePolicy.cs
+++ b/src/Lucene.Net.Misc/Index/Sorter/SortingMergePolicy.cs
@@ -234,7 +234,6 @@ namespace Lucene.Net.Index.Sorter
this.sort = sort;
}
- // LUCENENET TODO: Try to find a way to make MergeTrigger enumeration non-nullable (in core)
public override MergeSpecification FindMerges(MergeTrigger? mergeTrigger, SegmentInfos segmentInfos)
{
return SortedMergeSpecification(@in.FindMerges(mergeTrigger, segmentInfos));
[21/28] lucenenet git commit: Lucene.Net.Expressions: renamed
protected fields camelCase prefixed with m_
Posted by ni...@apache.org.
Lucene.Net.Expressions: renamed protected fields camelCase prefixed with m_
Project: http://git-wip-us.apache.org/repos/asf/lucenenet/repo
Commit: http://git-wip-us.apache.org/repos/asf/lucenenet/commit/b8753ba9
Tree: http://git-wip-us.apache.org/repos/asf/lucenenet/tree/b8753ba9
Diff: http://git-wip-us.apache.org/repos/asf/lucenenet/diff/b8753ba9
Branch: refs/heads/api-work
Commit: b8753ba9eaf1fc434f47a769a128f4e4e5b8b0e4
Parents: 247f50c
Author: Shad Storhaug <sh...@shadstorhaug.com>
Authored: Wed Feb 1 16:41:16 2017 +0700
Committer: Shad Storhaug <sh...@shadstorhaug.com>
Committed: Wed Feb 1 16:41:16 2017 +0700
----------------------------------------------------------------------
.../JS/JavascriptLexer.cs | 10 +-
.../JS/JavascriptParser.cs | 300 +++++++++----------
2 files changed, 155 insertions(+), 155 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b8753ba9/src/Lucene.Net.Expressions/JS/JavascriptLexer.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Expressions/JS/JavascriptLexer.cs b/src/Lucene.Net.Expressions/JS/JavascriptLexer.cs
index 606100d..416f4da 100644
--- a/src/Lucene.Net.Expressions/JS/JavascriptLexer.cs
+++ b/src/Lucene.Net.Expressions/JS/JavascriptLexer.cs
@@ -106,19 +106,19 @@ namespace Lucene.Net.Expressions.JS
public JavascriptLexer()
{
- dfa9 = new JavascriptLexer.DFA9(this, this);
+ m_dfa9 = new JavascriptLexer.DFA9(this, this);
}
public JavascriptLexer(ICharStream input) : this(input, new RecognizerSharedState(
))
{
- dfa9 = new JavascriptLexer.DFA9(this, this);
+ m_dfa9 = new JavascriptLexer.DFA9(this, this);
}
public JavascriptLexer(ICharStream input, RecognizerSharedState state) : base(input
, state)
{
- dfa9 = new JavascriptLexer.DFA9(this, this);
+ m_dfa9 = new JavascriptLexer.DFA9(this, this);
}
public override string GrammarFileName
@@ -933,7 +933,7 @@ loop2_break: ;
int channel = TokenChannels.Default;
// src/java/org/apache/lucene/expressions/js/Javascript.g:347:5: ( DECIMALINTEGER AT_DOT ( DECIMALDIGIT )* ( EXPONENT )? | AT_DOT ( DECIMALDIGIT )+ ( EXPONENT )? | DECIMALINTEGER ( EXPONENT )? )
int alt9 = 3;
- alt9 = dfa9.Predict(input);
+ alt9 = m_dfa9.Predict(input);
switch (alt9)
{
case 1:
@@ -2088,7 +2088,7 @@ loop2_break: ;
}
}
- protected JavascriptLexer.DFA9 dfa9;
+ protected JavascriptLexer.DFA9 m_dfa9;
internal static readonly string DFA9_eotS = "\x1\uffff\x2\x4\x3\uffff\x1\x4";
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b8753ba9/src/Lucene.Net.Expressions/JS/JavascriptParser.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Expressions/JS/JavascriptParser.cs b/src/Lucene.Net.Expressions/JS/JavascriptParser.cs
index d495943..6700990 100644
--- a/src/Lucene.Net.Expressions/JS/JavascriptParser.cs
+++ b/src/Lucene.Net.Expressions/JS/JavascriptParser.cs
@@ -118,12 +118,12 @@ namespace Lucene.Net.Expressions.JS
{
}
- protected ITreeAdaptor adaptor = new CommonTreeAdaptor();
+ protected ITreeAdaptor m_adaptor = new CommonTreeAdaptor();
public virtual ITreeAdaptor TreeAdaptor
{
- get { return adaptor; }
- set { adaptor = value; }
+ get { return m_adaptor; }
+ set { m_adaptor = value; }
}
// delegators
@@ -371,22 +371,22 @@ namespace Lucene.Net.Expressions.JS
{
// src/java/org/apache/lucene/expressions/js/Javascript.g:251:5: ( conditional EOF !)
// src/java/org/apache/lucene/expressions/js/Javascript.g:251:7: conditional EOF !
- root = (CommonTree)adaptor.Nil();
+ root = (CommonTree)m_adaptor.Nil();
PushFollow(FOLLOW_conditional_in_expression737);
conditional1 = Conditional();
state._fsp--;
- adaptor.AddChild(root, conditional1.Tree);
+ m_adaptor.AddChild(root, conditional1.Tree);
EOF2 = (IToken)Match(input, EOF, FOLLOW_EOF_in_expression739);
}
retval.Stop = input.LT(-1);
- retval.Tree = (CommonTree)adaptor.RulePostProcessing(root);
- adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
+ retval.Tree = (CommonTree)m_adaptor.RulePostProcessing(root);
+ m_adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input, re);
- retval.Tree = (CommonTree)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);
+ retval.Tree = (CommonTree)m_adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);
}
// do for sure before leaving
return retval;
@@ -412,11 +412,11 @@ namespace Lucene.Net.Expressions.JS
{
// src/java/org/apache/lucene/expressions/js/Javascript.g:255:5: ( logical_or ( AT_COND_QUE ^ conditional AT_COLON ! conditional )? )
// src/java/org/apache/lucene/expressions/js/Javascript.g:255:7: logical_or ( AT_COND_QUE ^ conditional AT_COLON ! conditional )?
- root_0 = (CommonTree)adaptor.Nil();
+ root_0 = (CommonTree)m_adaptor.Nil();
PushFollow(FOLLOW_logical_or_in_conditional757);
logical_or3 = Logical_Or();
state._fsp--;
- adaptor.AddChild(root_0, logical_or3.Tree);
+ m_adaptor.AddChild(root_0, logical_or3.Tree);
// src/java/org/apache/lucene/expressions/js/Javascript.g:255:18: ( AT_COND_QUE ^ conditional AT_COLON ! conditional )?
int alt1 = 2;
int LA1_0 = input.LA(1);
@@ -430,30 +430,30 @@ namespace Lucene.Net.Expressions.JS
{
// src/java/org/apache/lucene/expressions/js/Javascript.g:255:19: AT_COND_QUE ^ conditional AT_COLON ! conditional
AT_COND_QUE4 = (IToken)Match(input, AT_COND_QUE, FOLLOW_AT_COND_QUE_in_conditional760);
- AT_COND_QUE4_tree = (CommonTree)adaptor.Create(AT_COND_QUE4);
- root_0 = (CommonTree)adaptor.BecomeRoot(AT_COND_QUE4_tree, root_0);
+ AT_COND_QUE4_tree = (CommonTree)m_adaptor.Create(AT_COND_QUE4);
+ root_0 = (CommonTree)m_adaptor.BecomeRoot(AT_COND_QUE4_tree, root_0);
PushFollow(FOLLOW_conditional_in_conditional763);
conditional5 = Conditional();
state._fsp--;
- adaptor.AddChild(root_0, conditional5.Tree);
+ m_adaptor.AddChild(root_0, conditional5.Tree);
AT_COLON6 = (IToken)Match(input, AT_COLON, FOLLOW_AT_COLON_in_conditional765);
PushFollow(FOLLOW_conditional_in_conditional768);
conditional7 = Conditional();
state._fsp--;
- adaptor.AddChild(root_0, conditional7.Tree);
+ m_adaptor.AddChild(root_0, conditional7.Tree);
break;
}
}
}
retval.Stop = input.LT(-1);
- retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
- adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
+ retval.Tree = (CommonTree)m_adaptor.RulePostProcessing(root_0);
+ m_adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input, re);
- retval.Tree = (CommonTree)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);
+ retval.Tree = (CommonTree)m_adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);
}
// do for sure before leaving
return retval;
@@ -475,11 +475,11 @@ namespace Lucene.Net.Expressions.JS
{
// src/java/org/apache/lucene/expressions/js/Javascript.g:259:5: ( logical_and ( AT_BOOL_OR ^ logical_and )* )
// src/java/org/apache/lucene/expressions/js/Javascript.g:259:7: logical_and ( AT_BOOL_OR ^ logical_and )*
- root_0 = (CommonTree)adaptor.Nil();
+ root_0 = (CommonTree)m_adaptor.Nil();
PushFollow(FOLLOW_logical_and_in_logical_or787);
logical_and8 = Logical_And();
state._fsp--;
- adaptor.AddChild(root_0, logical_and8.Tree);
+ m_adaptor.AddChild(root_0, logical_and8.Tree);
// src/java/org/apache/lucene/expressions/js/Javascript.g:259:19: ( AT_BOOL_OR ^ logical_and )*
while (true)
{
@@ -495,12 +495,12 @@ namespace Lucene.Net.Expressions.JS
{
// src/java/org/apache/lucene/expressions/js/Javascript.g:259:20: AT_BOOL_OR ^ logical_and
AT_BOOL_OR9 = (IToken)Match(input, AT_BOOL_OR, FOLLOW_AT_BOOL_OR_in_logical_or790);
- AT_BOOL_OR9_tree = (CommonTree)adaptor.Create(AT_BOOL_OR9);
- root_0 = (CommonTree)adaptor.BecomeRoot(AT_BOOL_OR9_tree, root_0);
+ AT_BOOL_OR9_tree = (CommonTree)m_adaptor.Create(AT_BOOL_OR9);
+ root_0 = (CommonTree)m_adaptor.BecomeRoot(AT_BOOL_OR9_tree, root_0);
PushFollow(FOLLOW_logical_and_in_logical_or793);
logical_and10 = Logical_And();
state._fsp--;
- adaptor.AddChild(root_0, logical_and10.Tree);
+ m_adaptor.AddChild(root_0, logical_and10.Tree);
break;
}
@@ -514,14 +514,14 @@ namespace Lucene.Net.Expressions.JS
loop2_break: ;
}
retval.Stop = input.LT(-1);
- retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
- adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
+ retval.Tree = (CommonTree)m_adaptor.RulePostProcessing(root_0);
+ m_adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input, re);
- retval.Tree = (CommonTree)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);
+ retval.Tree = (CommonTree)m_adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);
}
// do for sure before leaving
return retval;
@@ -545,11 +545,11 @@ namespace Lucene.Net.Expressions.JS
{
// src/java/org/apache/lucene/expressions/js/Javascript.g:263:5: ( bitwise_or ( AT_BOOL_AND ^ bitwise_or )* )
// src/java/org/apache/lucene/expressions/js/Javascript.g:263:7: bitwise_or ( AT_BOOL_AND ^ bitwise_or )*
- root = (CommonTree)adaptor.Nil();
+ root = (CommonTree)m_adaptor.Nil();
PushFollow(FOLLOW_bitwise_or_in_logical_and812);
bitwise_or11 = Bitwise_Or();
state._fsp--;
- adaptor.AddChild(root, bitwise_or11.Tree);
+ m_adaptor.AddChild(root, bitwise_or11.Tree);
// src/java/org/apache/lucene/expressions/js/Javascript.g:263:18: ( AT_BOOL_AND ^ bitwise_or )*
while (true)
{
@@ -565,12 +565,12 @@ namespace Lucene.Net.Expressions.JS
{
// src/java/org/apache/lucene/expressions/js/Javascript.g:263:19: AT_BOOL_AND ^ bitwise_or
AT_BOOL_AND12 = (IToken)Match(input, AT_BOOL_AND, FOLLOW_AT_BOOL_AND_in_logical_and815);
- AT_BOOL_AND12_tree = (CommonTree)adaptor.Create(AT_BOOL_AND12);
- root = (CommonTree)adaptor.BecomeRoot(AT_BOOL_AND12_tree, root);
+ AT_BOOL_AND12_tree = (CommonTree)m_adaptor.Create(AT_BOOL_AND12);
+ root = (CommonTree)m_adaptor.BecomeRoot(AT_BOOL_AND12_tree, root);
PushFollow(FOLLOW_bitwise_or_in_logical_and818);
bitwise_or13 = Bitwise_Or();
state._fsp--;
- adaptor.AddChild(root, bitwise_or13.Tree);
+ m_adaptor.AddChild(root, bitwise_or13.Tree);
break;
}
@@ -584,14 +584,14 @@ namespace Lucene.Net.Expressions.JS
loop3_break: ;
}
retval.Stop = input.LT(-1);
- retval.Tree = (CommonTree)adaptor.RulePostProcessing(root);
- adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
+ retval.Tree = (CommonTree)m_adaptor.RulePostProcessing(root);
+ m_adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input, re);
- retval.Tree = (CommonTree)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re
+ retval.Tree = (CommonTree)m_adaptor.ErrorNode(input, retval.Start, input.LT(-1), re
);
}
// do for sure before leaving
@@ -610,11 +610,11 @@ namespace Lucene.Net.Expressions.JS
{
// src/java/org/apache/lucene/expressions/js/Javascript.g:267:5: ( bitwise_xor ( AT_BIT_OR ^ bitwise_xor )* )
// src/java/org/apache/lucene/expressions/js/Javascript.g:267:7: bitwise_xor ( AT_BIT_OR ^ bitwise_xor )*
- root = (CommonTree)adaptor.Nil();
+ root = (CommonTree)m_adaptor.Nil();
PushFollow(FOLLOW_bitwise_xor_in_bitwise_or837);
AstParserRuleReturnScope<ITree, IToken> bitwise_xor14 = Bitwise_XOr();
state._fsp--;
- adaptor.AddChild(root, bitwise_xor14.Tree);
+ m_adaptor.AddChild(root, bitwise_xor14.Tree);
// src/java/org/apache/lucene/expressions/js/Javascript.g:267:19: ( AT_BIT_OR ^ bitwise_xor )*
while (true)
{
@@ -630,12 +630,12 @@ namespace Lucene.Net.Expressions.JS
{
// src/java/org/apache/lucene/expressions/js/Javascript.g:267:20: AT_BIT_OR ^ bitwise_xor
IToken AT_BIT_OR15 = (IToken)Match(input, AT_BIT_OR, FOLLOW_AT_BIT_OR_in_bitwise_or840);
- CommonTree AT_BIT_OR15_tree = (CommonTree)adaptor.Create(AT_BIT_OR15);
- root = (CommonTree)adaptor.BecomeRoot(AT_BIT_OR15_tree, root);
+ CommonTree AT_BIT_OR15_tree = (CommonTree)m_adaptor.Create(AT_BIT_OR15);
+ root = (CommonTree)m_adaptor.BecomeRoot(AT_BIT_OR15_tree, root);
PushFollow(FOLLOW_bitwise_xor_in_bitwise_or843);
AstParserRuleReturnScope<ITree, IToken> bitwise_xor16 = Bitwise_XOr();
state._fsp--;
- adaptor.AddChild(root, bitwise_xor16.Tree);
+ m_adaptor.AddChild(root, bitwise_xor16.Tree);
break;
}
@@ -649,14 +649,14 @@ namespace Lucene.Net.Expressions.JS
loop4_break: ;
}
retval.Stop = input.LT(-1);
- retval.Tree = (CommonTree)adaptor.RulePostProcessing(root);
- adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
+ retval.Tree = (CommonTree)m_adaptor.RulePostProcessing(root);
+ m_adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input, re);
- retval.Tree = (CommonTree)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);
+ retval.Tree = (CommonTree)m_adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);
}
// do for sure before leaving
return retval;
@@ -674,11 +674,11 @@ namespace Lucene.Net.Expressions.JS
{
// src/java/org/apache/lucene/expressions/js/Javascript.g:271:5: ( bitwise_and ( AT_BIT_XOR ^ bitwise_and )* )
// src/java/org/apache/lucene/expressions/js/Javascript.g:271:7: bitwise_and ( AT_BIT_XOR ^ bitwise_and )*
- root = (CommonTree)adaptor.Nil();
+ root = (CommonTree)m_adaptor.Nil();
PushFollow(FOLLOW_bitwise_and_in_bitwise_xor862);
AstParserRuleReturnScope<ITree, IToken> bitwise_and17 = Bitwise_And();
state._fsp--;
- adaptor.AddChild(root, bitwise_and17.Tree);
+ m_adaptor.AddChild(root, bitwise_and17.Tree);
// src/java/org/apache/lucene/expressions/js/Javascript.g:271:19: ( AT_BIT_XOR ^ bitwise_and )*
while (true)
{
@@ -695,12 +695,12 @@ namespace Lucene.Net.Expressions.JS
// src/java/org/apache/lucene/expressions/js/Javascript.g:271:20: AT_BIT_XOR ^ bitwise_and
IToken AT_BIT_XOR18 = (IToken)Match(input, AT_BIT_XOR, FOLLOW_AT_BIT_XOR_in_bitwise_xor865
);
- CommonTree AT_BIT_XOR18_tree = (CommonTree)adaptor.Create(AT_BIT_XOR18);
- root = (CommonTree)adaptor.BecomeRoot(AT_BIT_XOR18_tree, root);
+ CommonTree AT_BIT_XOR18_tree = (CommonTree)m_adaptor.Create(AT_BIT_XOR18);
+ root = (CommonTree)m_adaptor.BecomeRoot(AT_BIT_XOR18_tree, root);
PushFollow(FOLLOW_bitwise_and_in_bitwise_xor868);
AstParserRuleReturnScope<ITree, IToken> bitwise_and19 = Bitwise_And();
state._fsp--;
- adaptor.AddChild(root, bitwise_and19.Tree);
+ m_adaptor.AddChild(root, bitwise_and19.Tree);
break;
}
@@ -714,14 +714,14 @@ namespace Lucene.Net.Expressions.JS
loop5_break: ;
}
retval.Stop = input.LT(-1);
- retval.Tree = (CommonTree)adaptor.RulePostProcessing(root);
- adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
+ retval.Tree = (CommonTree)m_adaptor.RulePostProcessing(root);
+ m_adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input, re);
- retval.Tree = (CommonTree)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re
+ retval.Tree = (CommonTree)m_adaptor.ErrorNode(input, retval.Start, input.LT(-1), re
);
}
// do for sure before leaving
@@ -741,11 +741,11 @@ namespace Lucene.Net.Expressions.JS
{
// src/java/org/apache/lucene/expressions/js/Javascript.g:275:5: ( equality ( AT_BIT_AND ^ equality )* )
// src/java/org/apache/lucene/expressions/js/Javascript.g:275:8: equality ( AT_BIT_AND ^ equality )*
- root = (CommonTree)adaptor.Nil();
+ root = (CommonTree)m_adaptor.Nil();
PushFollow(FOLLOW_equality_in_bitwise_and888);
AstParserRuleReturnScope<ITree, IToken> equality20 = Equality();
state._fsp--;
- adaptor.AddChild(root, equality20.Tree);
+ m_adaptor.AddChild(root, equality20.Tree);
// src/java/org/apache/lucene/expressions/js/Javascript.g:275:17: ( AT_BIT_AND ^ equality )*
while (true)
{
@@ -762,12 +762,12 @@ namespace Lucene.Net.Expressions.JS
// src/java/org/apache/lucene/expressions/js/Javascript.g:275:18: AT_BIT_AND ^ equality
IToken AT_BIT_AND21 = (IToken)Match(input, AT_BIT_AND, FOLLOW_AT_BIT_AND_in_bitwise_and891
);
- CommonTree AT_BIT_AND21_tree = (CommonTree)adaptor.Create(AT_BIT_AND21);
- root = (CommonTree)adaptor.BecomeRoot(AT_BIT_AND21_tree, root);
+ CommonTree AT_BIT_AND21_tree = (CommonTree)m_adaptor.Create(AT_BIT_AND21);
+ root = (CommonTree)m_adaptor.BecomeRoot(AT_BIT_AND21_tree, root);
PushFollow(FOLLOW_equality_in_bitwise_and894);
AstParserRuleReturnScope<ITree, IToken> equality22 = Equality();
state._fsp--;
- adaptor.AddChild(root, equality22.Tree);
+ m_adaptor.AddChild(root, equality22.Tree);
break;
}
@@ -781,14 +781,14 @@ namespace Lucene.Net.Expressions.JS
loop6_break: ;
}
retval.Stop = input.LT(-1);
- retval.Tree = (CommonTree)adaptor.RulePostProcessing(root);
- adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
+ retval.Tree = (CommonTree)m_adaptor.RulePostProcessing(root);
+ m_adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input, re);
- retval.Tree = (CommonTree)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);
+ retval.Tree = (CommonTree)m_adaptor.ErrorNode(input, retval.Start, input.LT(-1), re);
}
// do for sure before leaving
return retval;
@@ -807,11 +807,11 @@ namespace Lucene.Net.Expressions.JS
{
// src/java/org/apache/lucene/expressions/js/Javascript.g:279:5: ( relational ( ( AT_COMP_EQ | AT_COMP_NEQ ) ^ relational )* )
// src/java/org/apache/lucene/expressions/js/Javascript.g:279:7: relational ( ( AT_COMP_EQ | AT_COMP_NEQ ) ^ relational )*
- root = (CommonTree)adaptor.Nil();
+ root = (CommonTree)m_adaptor.Nil();
PushFollow(FOLLOW_relational_in_equality913);
AstParserRuleReturnScope<ITree, IToken> relational23 = Relational();
state._fsp--;
- adaptor.AddChild(root, relational23.Tree);
+ m_adaptor.AddChild(root, relational23.Tree);
// src/java/org/apache/lucene/expressions/js/Javascript.g:279:18: ( ( AT_COMP_EQ | AT_COMP_NEQ ) ^ relational )*
while (true)
{
@@ -831,7 +831,7 @@ namespace Lucene.Net.Expressions.JS
if (input.LA(1) == AT_COMP_EQ || input.LA(1) == AT_COMP_NEQ)
{
input.Consume();
- root = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(set24), root
+ root = (CommonTree)m_adaptor.BecomeRoot((CommonTree)m_adaptor.Create(set24), root
);
state.errorRecovery = false;
}
@@ -843,7 +843,7 @@ namespace Lucene.Net.Expressions.JS
PushFollow(FOLLOW_relational_in_equality925);
AstParserRuleReturnScope<ITree, IToken> relational25 = Relational();
state._fsp--;
- adaptor.AddChild(root, relational25.Tree);
+ m_adaptor.AddChild(root, relational25.Tree);
break;
}
@@ -857,14 +857,14 @@ namespace Lucene.Net.Expressions.JS
loop7_break: ;
}
retval.Stop = input.LT(-1);
- retval.Tree = (CommonTree)adaptor.RulePostProcessing(root);
- adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
+ retval.Tree = (CommonTree)m_adaptor.RulePostProcessing(root);
+ m_adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input, re);
- retval.Tree = (CommonTree)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re
+ retval.Tree = (CommonTree)m_adaptor.ErrorNode(input, retval.Start, input.LT(-1), re
);
}
// do for sure before leaving
@@ -885,11 +885,11 @@ namespace Lucene.Net.Expressions.JS
{
// src/java/org/apache/lucene/expressions/js/Javascript.g:283:5: ( shift ( ( AT_COMP_LT | AT_COMP_GT | AT_COMP_LTE | AT_COMP_GTE ) ^ shift )* )
// src/java/org/apache/lucene/expressions/js/Javascript.g:283:7: shift ( ( AT_COMP_LT | AT_COMP_GT | AT_COMP_LTE | AT_COMP_GTE ) ^ shift )*
- root = (CommonTree)adaptor.Nil();
+ root = (CommonTree)m_adaptor.Nil();
PushFollow(FOLLOW_shift_in_relational944);
AstParserRuleReturnScope<ITree, IToken> shift26 = Shift();
state._fsp--;
- adaptor.AddChild(root, shift26.Tree);
+ m_adaptor.AddChild(root, shift26.Tree);
// src/java/org/apache/lucene/expressions/js/Javascript.g:283:13: ( ( AT_COMP_LT | AT_COMP_GT | AT_COMP_LTE | AT_COMP_GTE ) ^ shift )*
while (true)
{
@@ -909,7 +909,7 @@ namespace Lucene.Net.Expressions.JS
if ((input.LA(1) >= AT_COMP_GT && input.LA(1) <= AT_COMP_LTE))
{
input.Consume();
- root = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(set27), root
+ root = (CommonTree)m_adaptor.BecomeRoot((CommonTree)m_adaptor.Create(set27), root
);
state.errorRecovery = false;
}
@@ -921,7 +921,7 @@ namespace Lucene.Net.Expressions.JS
PushFollow(FOLLOW_shift_in_relational964);
AstParserRuleReturnScope<ITree, IToken> shift28 = Shift();
state._fsp--;
- adaptor.AddChild(root, shift28.Tree);
+ m_adaptor.AddChild(root, shift28.Tree);
break;
}
@@ -935,14 +935,14 @@ namespace Lucene.Net.Expressions.JS
loop8_break: ;
}
retval.Stop = input.LT(-1);
- retval.Tree = (CommonTree)adaptor.RulePostProcessing(root);
- adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
+ retval.Tree = (CommonTree)m_adaptor.RulePostProcessing(root);
+ m_adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input, re);
- retval.Tree = (CommonTree)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re
+ retval.Tree = (CommonTree)m_adaptor.ErrorNode(input, retval.Start, input.LT(-1), re
);
}
// do for sure before leaving
@@ -963,11 +963,11 @@ namespace Lucene.Net.Expressions.JS
{
// src/java/org/apache/lucene/expressions/js/Javascript.g:287:5: ( additive ( ( AT_BIT_SHL | AT_BIT_SHR | AT_BIT_SHU ) ^ additive )* )
// src/java/org/apache/lucene/expressions/js/Javascript.g:287:7: additive ( ( AT_BIT_SHL | AT_BIT_SHR | AT_BIT_SHU ) ^ additive )*
- root = (CommonTree)adaptor.Nil();
+ root = (CommonTree)m_adaptor.Nil();
PushFollow(FOLLOW_additive_in_shift983);
AstParserRuleReturnScope<ITree, IToken> additive29 = Additive();
state._fsp--;
- adaptor.AddChild(root, additive29.Tree);
+ m_adaptor.AddChild(root, additive29.Tree);
// src/java/org/apache/lucene/expressions/js/Javascript.g:287:16: ( ( AT_BIT_SHL | AT_BIT_SHR | AT_BIT_SHU ) ^ additive )*
while (true)
{
@@ -987,7 +987,7 @@ namespace Lucene.Net.Expressions.JS
if ((input.LA(1) >= AT_BIT_SHL && input.LA(1) <= AT_BIT_SHU))
{
input.Consume();
- root = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(set30), root
+ root = (CommonTree)m_adaptor.BecomeRoot((CommonTree)m_adaptor.Create(set30), root
);
state.errorRecovery = false;
}
@@ -999,7 +999,7 @@ namespace Lucene.Net.Expressions.JS
PushFollow(FOLLOW_additive_in_shift999);
AstParserRuleReturnScope<ITree, IToken> additive31 = Additive();
state._fsp--;
- adaptor.AddChild(root, additive31.Tree);
+ m_adaptor.AddChild(root, additive31.Tree);
break;
}
@@ -1013,14 +1013,14 @@ namespace Lucene.Net.Expressions.JS
loop9_break: ;
}
retval.Stop = input.LT(-1);
- retval.Tree = (CommonTree)adaptor.RulePostProcessing(root);
- adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
+ retval.Tree = (CommonTree)m_adaptor.RulePostProcessing(root);
+ m_adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input, re);
- retval.Tree = (CommonTree)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re
+ retval.Tree = (CommonTree)m_adaptor.ErrorNode(input, retval.Start, input.LT(-1), re
);
}
// do for sure before leaving
@@ -1041,11 +1041,11 @@ namespace Lucene.Net.Expressions.JS
{
// src/java/org/apache/lucene/expressions/js/Javascript.g:291:5: ( multiplicative ( ( AT_ADD | AT_SUBTRACT ) ^ multiplicative )* )
// src/java/org/apache/lucene/expressions/js/Javascript.g:291:7: multiplicative ( ( AT_ADD | AT_SUBTRACT ) ^ multiplicative )*
- root = (CommonTree)adaptor.Nil();
+ root = (CommonTree)m_adaptor.Nil();
PushFollow(FOLLOW_multiplicative_in_additive1018);
AstParserRuleReturnScope<ITree, IToken> multiplicative32 = Multiplicative();
state._fsp--;
- adaptor.AddChild(root, multiplicative32.Tree);
+ m_adaptor.AddChild(root, multiplicative32.Tree);
// src/java/org/apache/lucene/expressions/js/Javascript.g:291:22: ( ( AT_ADD | AT_SUBTRACT ) ^ multiplicative )*
while (true)
{
@@ -1065,7 +1065,7 @@ namespace Lucene.Net.Expressions.JS
if (input.LA(1) == AT_ADD || input.LA(1) == AT_SUBTRACT)
{
input.Consume();
- root = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(set33), root
+ root = (CommonTree)m_adaptor.BecomeRoot((CommonTree)m_adaptor.Create(set33), root
);
state.errorRecovery = false;
}
@@ -1077,7 +1077,7 @@ namespace Lucene.Net.Expressions.JS
PushFollow(FOLLOW_multiplicative_in_additive1030);
AstParserRuleReturnScope<ITree, IToken> multiplicative34 = Multiplicative();
state._fsp--;
- adaptor.AddChild(root, multiplicative34.Tree);
+ m_adaptor.AddChild(root, multiplicative34.Tree);
break;
}
@@ -1091,14 +1091,14 @@ namespace Lucene.Net.Expressions.JS
loop10_break: ;
}
retval.Stop = input.LT(-1);
- retval.Tree = (CommonTree)adaptor.RulePostProcessing(root);
- adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
+ retval.Tree = (CommonTree)m_adaptor.RulePostProcessing(root);
+ m_adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input, re);
- retval.Tree = (CommonTree)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re
+ retval.Tree = (CommonTree)m_adaptor.ErrorNode(input, retval.Start, input.LT(-1), re
);
}
// do for sure before leaving
@@ -1118,11 +1118,11 @@ namespace Lucene.Net.Expressions.JS
{
// src/java/org/apache/lucene/expressions/js/Javascript.g:295:5: ( unary ( ( AT_MULTIPLY | AT_DIVIDE | AT_MODULO ) ^ unary )* )
// src/java/org/apache/lucene/expressions/js/Javascript.g:295:7: unary ( ( AT_MULTIPLY | AT_DIVIDE | AT_MODULO ) ^ unary )*
- root = (CommonTree)adaptor.Nil();
+ root = (CommonTree)m_adaptor.Nil();
PushFollow(FOLLOW_unary_in_multiplicative1049);
AstParserRuleReturnScope<ITree, IToken> unary35 = Unary();
state._fsp--;
- adaptor.AddChild(root, unary35.Tree);
+ m_adaptor.AddChild(root, unary35.Tree);
// src/java/org/apache/lucene/expressions/js/Javascript.g:295:13: ( ( AT_MULTIPLY | AT_DIVIDE | AT_MODULO ) ^ unary )*
while (true)
{
@@ -1143,7 +1143,7 @@ namespace Lucene.Net.Expressions.JS
))
{
input.Consume();
- root = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(set36), root
+ root = (CommonTree)m_adaptor.BecomeRoot((CommonTree)m_adaptor.Create(set36), root
);
state.errorRecovery = false;
}
@@ -1155,7 +1155,7 @@ namespace Lucene.Net.Expressions.JS
PushFollow(FOLLOW_unary_in_multiplicative1065);
AstParserRuleReturnScope<ITree, IToken> unary37 = Unary();
state._fsp--;
- adaptor.AddChild(root, unary37.Tree);
+ m_adaptor.AddChild(root, unary37.Tree);
break;
}
@@ -1169,14 +1169,14 @@ namespace Lucene.Net.Expressions.JS
loop11_break: ;
}
retval.Stop = input.LT(-1);
- retval.Tree = (CommonTree)adaptor.RulePostProcessing(root);
- adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
+ retval.Tree = (CommonTree)m_adaptor.RulePostProcessing(root);
+ m_adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input, re);
- retval.Tree = (CommonTree)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re
+ retval.Tree = (CommonTree)m_adaptor.ErrorNode(input, retval.Start, input.LT(-1), re
);
}
// do for sure before leaving
@@ -1233,50 +1233,50 @@ namespace Lucene.Net.Expressions.JS
case 1:
{
// src/java/org/apache/lucene/expressions/js/Javascript.g:299:7: postfix
- root = (CommonTree)adaptor.Nil();
+ root = (CommonTree)m_adaptor.Nil();
PushFollow(FOLLOW_postfix_in_unary1084);
AstParserRuleReturnScope<ITree, IToken> postfix38 = Postfix();
state._fsp--;
- adaptor.AddChild(root, postfix38.Tree);
+ m_adaptor.AddChild(root, postfix38.Tree);
break;
}
case 2:
{
// src/java/org/apache/lucene/expressions/js/Javascript.g:300:7: AT_ADD ! unary
- root = (CommonTree)adaptor.Nil();
+ root = (CommonTree)m_adaptor.Nil();
IToken AT_ADD39 = (IToken)Match(input, AT_ADD, FOLLOW_AT_ADD_in_unary1092);
PushFollow(FOLLOW_unary_in_unary1095);
AstParserRuleReturnScope<ITree, IToken> unary40 = Unary();
state._fsp--;
- adaptor.AddChild(root, unary40.Tree);
+ m_adaptor.AddChild(root, unary40.Tree);
break;
}
case 3:
{
// src/java/org/apache/lucene/expressions/js/Javascript.g:301:7: unary_operator ^ unary
- root = (CommonTree)adaptor.Nil();
+ root = (CommonTree)m_adaptor.Nil();
PushFollow(FOLLOW_unary_operator_in_unary1103);
AstParserRuleReturnScope<ITree, IToken> unary_operator41 = Unary_Operator();
state._fsp--;
- root = (CommonTree)adaptor.BecomeRoot(unary_operator41.Tree, root);
+ root = (CommonTree)m_adaptor.BecomeRoot(unary_operator41.Tree, root);
PushFollow(FOLLOW_unary_in_unary1106);
AstParserRuleReturnScope<ITree, IToken> unary42 = Unary();
state._fsp--;
- adaptor.AddChild(root, unary42.Tree);
+ m_adaptor.AddChild(root, unary42.Tree);
break;
}
}
retval.Stop = input.LT(-1);
- retval.Tree = (CommonTree)adaptor.RulePostProcessing(root);
- adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
+ retval.Tree = (CommonTree)m_adaptor.RulePostProcessing(root);
+ m_adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input, re);
- retval.Tree = (CommonTree)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re
+ retval.Tree = (CommonTree)m_adaptor.ErrorNode(input, retval.Start, input.LT(-1), re
);
}
// do for sure before leaving
@@ -1292,7 +1292,7 @@ namespace Lucene.Net.Expressions.JS
var retval = new AstParserRuleReturnScope<ITree, IToken> { Start = input.LT(1) };
CommonTree root = null;
//CommonTree AT_SUBTRACT43_tree = null; // LUCENENET NOTE: Not used
- RewriteRuleTokenStream stream_AT_SUBTRACT = new RewriteRuleTokenStream(adaptor, "token AT_SUBTRACT"
+ RewriteRuleTokenStream stream_AT_SUBTRACT = new RewriteRuleTokenStream(m_adaptor, "token AT_SUBTRACT"
);
try
{
@@ -1340,12 +1340,12 @@ namespace Lucene.Net.Expressions.JS
// rule list labels:
// wildcard labels:
retval.Tree = root;
- RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval"
+ RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(m_adaptor, "rule retval"
, retval != null ? ((CommonTree)retval.Tree) : null);
- root = (CommonTree)adaptor.Nil();
+ root = (CommonTree)m_adaptor.Nil();
{
// 305:19: -> AT_NEGATE
- adaptor.AddChild(root, (CommonTree)adaptor.Create(AT_NEGATE, "AT_NEGATE"));
+ m_adaptor.AddChild(root, (CommonTree)m_adaptor.Create(AT_NEGATE, "AT_NEGATE"));
}
retval.Tree = root;
break;
@@ -1354,34 +1354,34 @@ namespace Lucene.Net.Expressions.JS
case 2:
{
// src/java/org/apache/lucene/expressions/js/Javascript.g:306:7: AT_BIT_NOT
- root = (CommonTree)adaptor.Nil();
+ root = (CommonTree)m_adaptor.Nil();
IToken AT_BIT_NOT44 = (IToken)Match(input, AT_BIT_NOT, FOLLOW_AT_BIT_NOT_in_unary_operator1135
);
- CommonTree AT_BIT_NOT44_tree = (CommonTree)adaptor.Create(AT_BIT_NOT44);
- adaptor.AddChild(root, AT_BIT_NOT44_tree);
+ CommonTree AT_BIT_NOT44_tree = (CommonTree)m_adaptor.Create(AT_BIT_NOT44);
+ m_adaptor.AddChild(root, AT_BIT_NOT44_tree);
break;
}
case 3:
{
// src/java/org/apache/lucene/expressions/js/Javascript.g:307:7: AT_BOOL_NOT
- root = (CommonTree)adaptor.Nil();
+ root = (CommonTree)m_adaptor.Nil();
IToken AT_BOOL_NOT45 = (IToken)Match(input, AT_BOOL_NOT, FOLLOW_AT_BOOL_NOT_in_unary_operator1143
);
- CommonTree AT_BOOL_NOT45_tree = (CommonTree)adaptor.Create(AT_BOOL_NOT45);
- adaptor.AddChild(root, AT_BOOL_NOT45_tree);
+ CommonTree AT_BOOL_NOT45_tree = (CommonTree)m_adaptor.Create(AT_BOOL_NOT45);
+ m_adaptor.AddChild(root, AT_BOOL_NOT45_tree);
break;
}
}
retval.Stop = input.LT(-1);
- retval.Tree = (CommonTree)adaptor.RulePostProcessing(root);
- adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
+ retval.Tree = (CommonTree)m_adaptor.RulePostProcessing(root);
+ m_adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input, re);
- retval.Tree = (CommonTree)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re
+ retval.Tree = (CommonTree)m_adaptor.ErrorNode(input, retval.Start, input.LT(-1), re
);
}
// do for sure before leaving
@@ -1396,8 +1396,8 @@ namespace Lucene.Net.Expressions.JS
var retval = new AstParserRuleReturnScope<ITree, IToken> { Start = input.LT(1) };
CommonTree root = null;
//CommonTree NAMESPACE_ID47_tree = null; // LUCENENET NOTE: Not used
- var streamNamespaceId = new RewriteRuleTokenStream(adaptor, "token NAMESPACE_ID");
- var streamArguments = new RewriteRuleSubtreeStream(adaptor, "rule arguments");
+ var streamNamespaceId = new RewriteRuleTokenStream(m_adaptor, "token NAMESPACE_ID");
+ var streamArguments = new RewriteRuleSubtreeStream(m_adaptor, "rule arguments");
try
{
// src/java/org/apache/lucene/expressions/js/Javascript.g:311:5: ( primary | NAMESPACE_ID arguments -> ^( AT_CALL NAMESPACE_ID ( arguments )? ) )
@@ -1453,11 +1453,11 @@ namespace Lucene.Net.Expressions.JS
case 1:
{
// src/java/org/apache/lucene/expressions/js/Javascript.g:311:7: primary
- root = (CommonTree)adaptor.Nil();
+ root = (CommonTree)m_adaptor.Nil();
PushFollow(FOLLOW_primary_in_postfix1160);
AstParserRuleReturnScope<ITree, IToken> primary46 = Primary();
state._fsp--;
- adaptor.AddChild(root, primary46.Tree);
+ m_adaptor.AddChild(root, primary46.Tree);
break;
}
@@ -1479,24 +1479,24 @@ namespace Lucene.Net.Expressions.JS
// rule list labels:
// wildcard labels:
retval.Tree = root;
- RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval"
+ RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(m_adaptor, "rule retval"
, retval != null ? ((CommonTree)retval.Tree) : null);
- root = (CommonTree)adaptor.Nil();
+ root = (CommonTree)m_adaptor.Nil();
{
{
// 312:30: -> ^( AT_CALL NAMESPACE_ID ( arguments )? )
// src/java/org/apache/lucene/expressions/js/Javascript.g:312:33: ^( AT_CALL NAMESPACE_ID ( arguments )? )
- CommonTree root_1 = (CommonTree)adaptor.Nil();
- root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(AT_CALL, "AT_CALL"
+ CommonTree root_1 = (CommonTree)m_adaptor.Nil();
+ root_1 = (CommonTree)m_adaptor.BecomeRoot((CommonTree)m_adaptor.Create(AT_CALL, "AT_CALL"
), root_1);
- adaptor.AddChild(root_1, streamNamespaceId.NextNode());
+ m_adaptor.AddChild(root_1, streamNamespaceId.NextNode());
// src/java/org/apache/lucene/expressions/js/Javascript.g:312:56: ( arguments )?
if (streamArguments.HasNext)
{
- adaptor.AddChild(root_1, streamArguments.NextTree());
+ m_adaptor.AddChild(root_1, streamArguments.NextTree());
}
streamArguments.Reset();
- adaptor.AddChild(root, root_1);
+ m_adaptor.AddChild(root, root_1);
}
}
retval.Tree = root;
@@ -1504,14 +1504,14 @@ namespace Lucene.Net.Expressions.JS
}
}
retval.Stop = input.LT(-1);
- retval.Tree = (CommonTree)adaptor.RulePostProcessing(root);
- adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
+ retval.Tree = (CommonTree)m_adaptor.RulePostProcessing(root);
+ m_adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input, re);
- retval.Tree = (CommonTree)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re
+ retval.Tree = (CommonTree)m_adaptor.ErrorNode(input, retval.Start, input.LT(-1), re
);
}
// do for sure before leaving
@@ -1568,47 +1568,47 @@ namespace Lucene.Net.Expressions.JS
case 1:
{
// src/java/org/apache/lucene/expressions/js/Javascript.g:316:7: NAMESPACE_ID
- root = (CommonTree)adaptor.Nil();
+ root = (CommonTree)m_adaptor.Nil();
IToken NAMESPACE_ID49 = (IToken)Match(input, NAMESPACE_ID, FOLLOW_NAMESPACE_ID_in_primary1198
);
- NAMESPACE_ID49_tree = (CommonTree)adaptor.Create(NAMESPACE_ID49);
- adaptor.AddChild(root, NAMESPACE_ID49_tree);
+ NAMESPACE_ID49_tree = (CommonTree)m_adaptor.Create(NAMESPACE_ID49);
+ m_adaptor.AddChild(root, NAMESPACE_ID49_tree);
break;
}
case 2:
{
// src/java/org/apache/lucene/expressions/js/Javascript.g:317:7: numeric
- root = (CommonTree)adaptor.Nil();
+ root = (CommonTree)m_adaptor.Nil();
PushFollow(FOLLOW_numeric_in_primary1206);
AstParserRuleReturnScope<ITree, IToken> numeric50 = Numeric();
state._fsp--;
- adaptor.AddChild(root, numeric50.Tree);
+ m_adaptor.AddChild(root, numeric50.Tree);
break;
}
case 3:
{
// src/java/org/apache/lucene/expressions/js/Javascript.g:318:7: AT_LPAREN ! conditional AT_RPAREN !
- root = (CommonTree)adaptor.Nil();
+ root = (CommonTree)m_adaptor.Nil();
AT_LPAREN51 = (IToken)Match(input, AT_LPAREN, FOLLOW_AT_LPAREN_in_primary1214);
PushFollow(FOLLOW_conditional_in_primary1217);
AstParserRuleReturnScope<ITree, IToken> conditional52 = Conditional();
state._fsp--;
- adaptor.AddChild(root, conditional52.Tree);
+ m_adaptor.AddChild(root, conditional52.Tree);
AT_RPAREN53 = (IToken)Match(input, AT_RPAREN, FOLLOW_AT_RPAREN_in_primary1219);
break;
}
}
retval.Stop = input.LT(-1);
- retval.Tree = (CommonTree)adaptor.RulePostProcessing(root);
- adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
+ retval.Tree = (CommonTree)m_adaptor.RulePostProcessing(root);
+ m_adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input, re);
- retval.Tree = (CommonTree)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re
+ retval.Tree = (CommonTree)m_adaptor.ErrorNode(input, retval.Start, input.LT(-1), re
);
}
// do for sure before leaving
@@ -1633,7 +1633,7 @@ namespace Lucene.Net.Expressions.JS
{
// src/java/org/apache/lucene/expressions/js/Javascript.g:322:5: ( AT_LPAREN ! ( conditional ( AT_COMMA ! conditional )* )? AT_RPAREN !)
// src/java/org/apache/lucene/expressions/js/Javascript.g:322:7: AT_LPAREN ! ( conditional ( AT_COMMA ! conditional )* )? AT_RPAREN !
- root = (CommonTree)adaptor.Nil();
+ root = (CommonTree)m_adaptor.Nil();
AT_LPAREN54 = (IToken)Match(input, AT_LPAREN, FOLLOW_AT_LPAREN_in_arguments1237);
// src/java/org/apache/lucene/expressions/js/Javascript.g:322:18: ( conditional ( AT_COMMA ! conditional )* )?
int alt17 = 2;
@@ -1652,7 +1652,7 @@ namespace Lucene.Net.Expressions.JS
PushFollow(FOLLOW_conditional_in_arguments1241);
AstParserRuleReturnScope<ITree, IToken> conditional55 = Conditional();
state._fsp--;
- adaptor.AddChild(root, conditional55.Tree);
+ m_adaptor.AddChild(root, conditional55.Tree);
// src/java/org/apache/lucene/expressions/js/Javascript.g:322:31: ( AT_COMMA ! conditional )*
while (true)
{
@@ -1671,7 +1671,7 @@ namespace Lucene.Net.Expressions.JS
PushFollow(FOLLOW_conditional_in_arguments1247);
AstParserRuleReturnScope<ITree, IToken> conditional57 = Conditional();
state._fsp--;
- adaptor.AddChild(root, conditional57.Tree);
+ m_adaptor.AddChild(root, conditional57.Tree);
break;
}
@@ -1689,14 +1689,14 @@ namespace Lucene.Net.Expressions.JS
AT_RPAREN58 = (IToken)Match(input, AT_RPAREN, FOLLOW_AT_RPAREN_in_arguments1253);
}
retval.Stop = input.LT(-1);
- retval.Tree = (CommonTree)adaptor.RulePostProcessing(root);
- adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
+ retval.Tree = (CommonTree)m_adaptor.RulePostProcessing(root);
+ m_adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input, re);
- retval.Tree = (CommonTree)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re
+ retval.Tree = (CommonTree)m_adaptor.ErrorNode(input, retval.Start, input.LT(-1), re
);
}
// do for sure before leaving
@@ -1718,12 +1718,12 @@ namespace Lucene.Net.Expressions.JS
{
// src/java/org/apache/lucene/expressions/js/Javascript.g:326:5: ( HEX | OCTAL | DECIMAL )
// src/java/org/apache/lucene/expressions/js/Javascript.g:
- root = (CommonTree)adaptor.Nil();
+ root = (CommonTree)m_adaptor.Nil();
IToken set59 = input.LT(1);
if (input.LA(1) == DECIMAL || input.LA(1) == HEX || input.LA(1) == OCTAL)
{
input.Consume();
- adaptor.AddChild(root, (CommonTree)adaptor.Create(set59));
+ m_adaptor.AddChild(root, (CommonTree)m_adaptor.Create(set59));
state.errorRecovery = false;
}
else
@@ -1733,14 +1733,14 @@ namespace Lucene.Net.Expressions.JS
}
}
retval.Stop = input.LT(-1);
- retval.Tree = (CommonTree)adaptor.RulePostProcessing(root);
- adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
+ retval.Tree = (CommonTree)m_adaptor.RulePostProcessing(root);
+ m_adaptor.SetTokenBoundaries(retval.Tree, retval.Start, retval.Stop);
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input, re);
- retval.Tree = (CommonTree)adaptor.ErrorNode(input, retval.Start, input.LT(-1), re
+ retval.Tree = (CommonTree)m_adaptor.ErrorNode(input, retval.Start, input.LT(-1), re
);
}
// do for sure before leaving
[04/28] lucenenet git commit:
Lucene.Net.Misc.Sorter.EarlyTerminatingSortingCollector: renamed protected
fields camelCase prefixed with m_
Posted by ni...@apache.org.
Lucene.Net.Misc.Sorter.EarlyTerminatingSortingCollector: renamed protected fields camelCase prefixed with m_
Project: http://git-wip-us.apache.org/repos/asf/lucenenet/repo
Commit: http://git-wip-us.apache.org/repos/asf/lucenenet/commit/30f99597
Tree: http://git-wip-us.apache.org/repos/asf/lucenenet/tree/30f99597
Diff: http://git-wip-us.apache.org/repos/asf/lucenenet/diff/30f99597
Branch: refs/heads/api-work
Commit: 30f995978ec586946c54e0b4088544eefdb2c386
Parents: 81158d8
Author: Shad Storhaug <sh...@shadstorhaug.com>
Authored: Wed Feb 1 13:23:18 2017 +0700
Committer: Shad Storhaug <sh...@shadstorhaug.com>
Committed: Wed Feb 1 13:23:18 2017 +0700
----------------------------------------------------------------------
.../Sorter/EarlyTerminatingSortingCollector.cs | 34 ++++++++++----------
.../Index/Sorter/TestEarlyTermination.cs | 2 +-
2 files changed, 18 insertions(+), 18 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/30f99597/src/Lucene.Net.Misc/Index/Sorter/EarlyTerminatingSortingCollector.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Misc/Index/Sorter/EarlyTerminatingSortingCollector.cs b/src/Lucene.Net.Misc/Index/Sorter/EarlyTerminatingSortingCollector.cs
index 1186340..2a5a6d9 100644
--- a/src/Lucene.Net.Misc/Index/Sorter/EarlyTerminatingSortingCollector.cs
+++ b/src/Lucene.Net.Misc/Index/Sorter/EarlyTerminatingSortingCollector.cs
@@ -28,7 +28,7 @@ namespace Lucene.Net.Index.Sorter
/// <para>
/// <b>NOTE:</b> the <see cref="ICollector"/> detects sorted segments according to
/// <see cref="SortingMergePolicy"/>, so it's best used in conjunction with it. Also,
- /// it collects up to a specified <see cref="numDocsToCollect"/> from each segment,
+ /// it collects up to a specified <see cref="m_numDocsToCollect"/> from each segment,
/// and therefore is mostly suitable for use in conjunction with collectors such as
/// <see cref="Search.TopDocsCollector{T}"/>, and not e.g. <see cref="TotalHitCountCollector"/>.
/// </para>
@@ -60,19 +60,19 @@ namespace Lucene.Net.Index.Sorter
{
/// <summary>
/// The wrapped Collector </summary>
- protected internal readonly ICollector @in;
+ protected readonly ICollector m_in;
/// <summary>
/// Sort used to sort the search results </summary>
- protected internal readonly Sort sort;
+ protected readonly Sort m_sort;
/// <summary>
/// Number of documents to collect in each segment </summary>
- protected internal readonly int numDocsToCollect;
+ protected readonly int m_numDocsToCollect;
/// <summary>
/// Number of documents to collect in the current segment being processed </summary>
- protected internal int segmentTotalCollect;
+ protected int m_segmentTotalCollect;
/// <summary>
/// True if the current segment being processed is sorted by <see cref="Sort()"/> </summary>
- protected internal bool segmentSorted;
+ protected bool m_segmentSorted;
private int numCollected;
@@ -91,22 +91,22 @@ namespace Lucene.Net.Index.Sorter
{
if (numDocsToCollect <= 0)
{
- throw new InvalidOperationException("numDocsToCollect must always be > 0, got " + segmentTotalCollect);
+ throw new InvalidOperationException("numDocsToCollect must always be > 0, got " + m_segmentTotalCollect);
}
- this.@in = @in;
- this.sort = sort;
- this.numDocsToCollect = numDocsToCollect;
+ this.m_in = @in;
+ this.m_sort = sort;
+ this.m_numDocsToCollect = numDocsToCollect;
}
public virtual void SetScorer(Scorer scorer)
{
- @in.SetScorer(scorer);
+ m_in.SetScorer(scorer);
}
public virtual void Collect(int doc)
{
- @in.Collect(doc);
- if (++numCollected >= segmentTotalCollect)
+ m_in.Collect(doc);
+ if (++numCollected >= m_segmentTotalCollect)
{
throw new CollectionTerminatedException();
}
@@ -114,15 +114,15 @@ namespace Lucene.Net.Index.Sorter
public virtual void SetNextReader(AtomicReaderContext context)
{
- @in.SetNextReader(context);
- segmentSorted = SortingMergePolicy.IsSorted(context.AtomicReader, sort);
- segmentTotalCollect = segmentSorted ? numDocsToCollect : int.MaxValue;
+ m_in.SetNextReader(context);
+ m_segmentSorted = SortingMergePolicy.IsSorted(context.AtomicReader, m_sort);
+ m_segmentTotalCollect = m_segmentSorted ? m_numDocsToCollect : int.MaxValue;
numCollected = 0;
}
public virtual bool AcceptsDocsOutOfOrder
{
- get { return !segmentSorted && @in.AcceptsDocsOutOfOrder; }
+ get { return !m_segmentSorted && m_in.AcceptsDocsOutOfOrder; }
}
}
}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/30f99597/src/Lucene.Net.Tests.Misc/Index/Sorter/TestEarlyTermination.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Misc/Index/Sorter/TestEarlyTermination.cs b/src/Lucene.Net.Tests.Misc/Index/Sorter/TestEarlyTermination.cs
index f50d13d..0c1ef35 100644
--- a/src/Lucene.Net.Tests.Misc/Index/Sorter/TestEarlyTermination.cs
+++ b/src/Lucene.Net.Tests.Misc/Index/Sorter/TestEarlyTermination.cs
@@ -155,7 +155,7 @@ namespace Lucene.Net.Index.Sorter
public override void SetNextReader(AtomicReaderContext context)
{
base.SetNextReader(context);
- assertFalse("segment should not be recognized as sorted as different sorter was used", segmentSorted);
+ assertFalse("segment should not be recognized as sorted as different sorter was used", m_segmentSorted);
}
}
[22/28] lucenenet git commit:
Lucene.Net.Expressions.JS.JavascriptParser.TokenNames: added WritableArray
and SuppressMessage attributes because it is an array property
Posted by ni...@apache.org.
Lucene.Net.Expressions.JS.JavascriptParser.TokenNames: added WritableArray and SuppressMessage attributes because it is an array property
Project: http://git-wip-us.apache.org/repos/asf/lucenenet/repo
Commit: http://git-wip-us.apache.org/repos/asf/lucenenet/commit/ba13cf44
Tree: http://git-wip-us.apache.org/repos/asf/lucenenet/tree/ba13cf44
Diff: http://git-wip-us.apache.org/repos/asf/lucenenet/diff/ba13cf44
Branch: refs/heads/api-work
Commit: ba13cf44270dceb67299ef2cd0446ee06d60ff97
Parents: b8753ba
Author: Shad Storhaug <sh...@shadstorhaug.com>
Authored: Wed Feb 1 16:57:54 2017 +0700
Committer: Shad Storhaug <sh...@shadstorhaug.com>
Committed: Wed Feb 1 16:57:54 2017 +0700
----------------------------------------------------------------------
src/Lucene.Net.Expressions/JS/JavascriptParser.cs | 7 +++++--
1 file changed, 5 insertions(+), 2 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/ba13cf44/src/Lucene.Net.Expressions/JS/JavascriptParser.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Expressions/JS/JavascriptParser.cs b/src/Lucene.Net.Expressions/JS/JavascriptParser.cs
index 6700990..0fea96c 100644
--- a/src/Lucene.Net.Expressions/JS/JavascriptParser.cs
+++ b/src/Lucene.Net.Expressions/JS/JavascriptParser.cs
@@ -1,8 +1,10 @@
// ANTLR GENERATED CODE: DO NOT EDIT (LUCENENET: Not really auto generated in the port)
-using System;
using Antlr.Runtime;
using Antlr.Runtime.Tree;
+using Lucene.Net.Support;
+using System;
+using System.Diagnostics.CodeAnalysis;
namespace Lucene.Net.Expressions.JS
{
@@ -128,7 +130,8 @@ namespace Lucene.Net.Expressions.JS
// delegators
-
+ [WritableArray]
+ [SuppressMessage("Microsoft.Performance", "CA1819", Justification = "Lucene's design requires some writable array properties")]
public override string[] TokenNames
{
get { return tokenNames; }
[20/28] lucenenet git commit: Lucene.Net.Tests.Expressions: added API
consistency tests
Posted by ni...@apache.org.
Lucene.Net.Tests.Expressions: added API consistency tests
Project: http://git-wip-us.apache.org/repos/asf/lucenenet/repo
Commit: http://git-wip-us.apache.org/repos/asf/lucenenet/commit/247f50ce
Tree: http://git-wip-us.apache.org/repos/asf/lucenenet/tree/247f50ce
Diff: http://git-wip-us.apache.org/repos/asf/lucenenet/diff/247f50ce
Branch: refs/heads/api-work
Commit: 247f50ceeb7a13b8c19bdbb73ce37971eaf8c8a1
Parents: 3a4c23e
Author: Shad Storhaug <sh...@shadstorhaug.com>
Authored: Wed Feb 1 16:33:15 2017 +0700
Committer: Shad Storhaug <sh...@shadstorhaug.com>
Committed: Wed Feb 1 16:33:15 2017 +0700
----------------------------------------------------------------------
.../Lucene.Net.Tests.Expressions.csproj | 1 +
.../TestApiConsistency.cs | 120 +++++++++++++++++++
2 files changed, 121 insertions(+)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/247f50ce/src/Lucene.Net.Tests.Expressions/Lucene.Net.Tests.Expressions.csproj
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Expressions/Lucene.Net.Tests.Expressions.csproj b/src/Lucene.Net.Tests.Expressions/Lucene.Net.Tests.Expressions.csproj
index 2fc503d..677289b 100644
--- a/src/Lucene.Net.Tests.Expressions/Lucene.Net.Tests.Expressions.csproj
+++ b/src/Lucene.Net.Tests.Expressions/Lucene.Net.Tests.Expressions.csproj
@@ -44,6 +44,7 @@
<Compile Include="JS\TestJavascriptFunction.cs" />
<Compile Include="JS\TestJavascriptOperations.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />
+ <Compile Include="TestApiConsistency.cs" />
<Compile Include="TestDemoExpressions.cs" />
<Compile Include="TestExpressionRescorer.cs" />
<Compile Include="TestExpressionSortField.cs" />
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/247f50ce/src/Lucene.Net.Tests.Expressions/TestApiConsistency.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Expressions/TestApiConsistency.cs b/src/Lucene.Net.Tests.Expressions/TestApiConsistency.cs
new file mode 100644
index 0000000..06ad62a
--- /dev/null
+++ b/src/Lucene.Net.Tests.Expressions/TestApiConsistency.cs
@@ -0,0 +1,120 @@
+\ufeffusing Lucene.Net.Attributes;
+using Lucene.Net.Util;
+using NUnit.Framework;
+using System;
+
+namespace Lucene.Net.Tests.Expressions
+{
+ /// <summary>
+ /// LUCENENET specific tests for ensuring API conventions are followed
+ /// </summary>
+ public class TestApiConsistency : ApiScanTestBase
+ {
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Expressions.Bindings))]
+ public override void TestProtectedFieldNames(Type typeFromTargetAssembly)
+ {
+ base.TestProtectedFieldNames(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Expressions.Bindings))]
+ public override void TestPrivateFieldNames(Type typeFromTargetAssembly)
+ {
+ base.TestPrivateFieldNames(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Expressions.Bindings))]
+ public override void TestPublicFields(Type typeFromTargetAssembly)
+ {
+ base.TestPublicFields(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Expressions.Bindings))]
+ public override void TestMethodParameterNames(Type typeFromTargetAssembly)
+ {
+ base.TestMethodParameterNames(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Expressions.Bindings))]
+ public override void TestInterfaceNames(Type typeFromTargetAssembly)
+ {
+ base.TestInterfaceNames(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Expressions.Bindings))]
+ public override void TestClassNames(Type typeFromTargetAssembly)
+ {
+ base.TestClassNames(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Expressions.Bindings))]
+ public override void TestForPropertiesWithNoGetter(Type typeFromTargetAssembly)
+ {
+ base.TestForPropertiesWithNoGetter(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Expressions.Bindings))]
+ public override void TestForPropertiesThatReturnArray(Type typeFromTargetAssembly)
+ {
+ base.TestForPropertiesThatReturnArray(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Expressions.Bindings))]
+ public override void TestForMethodsThatReturnWritableArray(Type typeFromTargetAssembly)
+ {
+ base.TestForMethodsThatReturnWritableArray(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Expressions.Bindings))]
+ public override void TestForPublicMembersContainingComparer(Type typeFromTargetAssembly)
+ {
+ base.TestForPublicMembersContainingComparer(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Expressions.Bindings))]
+ public override void TestForPublicMembersNamedSize(Type typeFromTargetAssembly)
+ {
+ base.TestForPublicMembersNamedSize(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Expressions.Bindings))]
+ public override void TestForPublicMembersContainingNonNetNumeric(Type typeFromTargetAssembly)
+ {
+ base.TestForPublicMembersContainingNonNetNumeric(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Expressions.Bindings))]
+ public override void TestForPublicMembersWithNullableEnum(Type typeFromTargetAssembly)
+ {
+ base.TestForPublicMembersWithNullableEnum(typeFromTargetAssembly);
+ }
+
+ // LUCENENET NOTE: This test is only for identifying members who were changed from
+ // ICollection, IList or ISet to IEnumerable during the port (that should be changed back)
+ //[Test, LuceneNetSpecific]
+ //[TestCase(typeof(Lucene.Net.Expressions.Bindings))]
+ //public override void TestForMembersAcceptingOrReturningIEnumerable(Type typeFromTargetAssembly)
+ //{
+ // base.TestForMembersAcceptingOrReturningIEnumerable(typeFromTargetAssembly);
+ //}
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Expressions.Bindings))]
+ public override void TestForMembersAcceptingOrReturningListOrDictionary(Type typeFromTargetAssembly)
+ {
+ base.TestForMembersAcceptingOrReturningListOrDictionary(typeFromTargetAssembly);
+ }
+ }
+}
[11/28] lucenenet git commit: Lucene.Net.Highlighter refactor:
renamed all protected fields camelCase prefixed with m_
Posted by ni...@apache.org.
Lucene.Net.Highlighter refactor: renamed all protected fields camelCase prefixed with m_
Project: http://git-wip-us.apache.org/repos/asf/lucenenet/repo
Commit: http://git-wip-us.apache.org/repos/asf/lucenenet/commit/350040c8
Tree: http://git-wip-us.apache.org/repos/asf/lucenenet/tree/350040c8
Diff: http://git-wip-us.apache.org/repos/asf/lucenenet/diff/350040c8
Branch: refs/heads/api-work
Commit: 350040c8356e18de4be8ca7f15df371b051cb552
Parents: fcf634f
Author: Shad Storhaug <sh...@shadstorhaug.com>
Authored: Wed Feb 1 14:02:02 2017 +0700
Committer: Shad Storhaug <sh...@shadstorhaug.com>
Committed: Wed Feb 1 14:02:02 2017 +0700
----------------------------------------------------------------------
.../Highlight/GradientFormatter.cs | 60 ++++++++++----------
.../Highlight/SpanGradientFormatter.cs | 4 +-
src/Lucene.Net.Highlighter/IcuBreakIterator.cs | 20 +++----
.../DefaultPassageFormatter.cs | 26 ++++-----
.../VectorHighlight/BaseFragmentsBuilder.cs | 14 ++---
.../VectorHighlight/SimpleBoundaryScanner.cs | 22 +++----
6 files changed, 73 insertions(+), 73 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/350040c8/src/Lucene.Net.Highlighter/Highlight/GradientFormatter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Highlighter/Highlight/GradientFormatter.cs b/src/Lucene.Net.Highlighter/Highlight/GradientFormatter.cs
index e94a309..fe386ca 100644
--- a/src/Lucene.Net.Highlighter/Highlight/GradientFormatter.cs
+++ b/src/Lucene.Net.Highlighter/Highlight/GradientFormatter.cs
@@ -27,12 +27,12 @@ namespace Lucene.Net.Search.Highlight
{
private float maxScore;
- protected internal int fgRMin, fgGMin, fgBMin;
- protected internal int fgRMax, fgGMax, fgBMax;
- protected bool highlightForeground;
- protected internal int bgRMin, bgGMin, bgBMin;
- protected internal int bgRMax, bgGMax, bgBMax;
- protected bool highlightBackground;
+ protected int m_fgRMin, m_fgGMin, m_fgBMin;
+ protected int m_fgRMax, m_fgGMax, m_fgBMax;
+ protected bool m_highlightForeground;
+ protected int m_bgRMin, m_bgGMin, m_bgBMin;
+ protected int m_bgRMax, m_bgGMax, m_bgBMax;
+ protected bool m_highlightBackground;
/// <summary> Sets the color range for the IDF scores</summary>
/// <param name="maxScore">
@@ -59,9 +59,9 @@ namespace Lucene.Net.Search.Highlight
string maxForegroundColor, string minBackgroundColor,
string maxBackgroundColor)
{
- highlightForeground = (minForegroundColor != null) && (maxForegroundColor != null);
+ m_highlightForeground = (minForegroundColor != null) && (maxForegroundColor != null);
- if (highlightForeground)
+ if (m_highlightForeground)
{
if (minForegroundColor.Length != 7)
{
@@ -73,18 +73,18 @@ namespace Lucene.Net.Search.Highlight
throw new ArgumentException("minForegroundColor is not 7 bytes long eg a hex "
+ "RGB value such as #FFFFFF");
}
- fgRMin = HexToInt(minForegroundColor.Substring(1, 3 - 1));
- fgGMin = HexToInt(minForegroundColor.Substring(3, 5 - 3));
- fgBMin = HexToInt(minForegroundColor.Substring(5, 7 - 5));
+ m_fgRMin = HexToInt(minForegroundColor.Substring(1, 3 - 1));
+ m_fgGMin = HexToInt(minForegroundColor.Substring(3, 5 - 3));
+ m_fgBMin = HexToInt(minForegroundColor.Substring(5, 7 - 5));
- fgRMax = HexToInt(maxForegroundColor.Substring(1, 3 - 1));
- fgGMax = HexToInt(maxForegroundColor.Substring(3, 5 - 3));
- fgBMax = HexToInt(maxForegroundColor.Substring(5, 7 - 5));
+ m_fgRMax = HexToInt(maxForegroundColor.Substring(1, 3 - 1));
+ m_fgGMax = HexToInt(maxForegroundColor.Substring(3, 5 - 3));
+ m_fgBMax = HexToInt(maxForegroundColor.Substring(5, 7 - 5));
}
- highlightBackground = (minBackgroundColor != null)
+ m_highlightBackground = (minBackgroundColor != null)
&& (maxBackgroundColor != null);
- if (highlightBackground)
+ if (m_highlightBackground)
{
if (minBackgroundColor.Length != 7)
{
@@ -96,13 +96,13 @@ namespace Lucene.Net.Search.Highlight
throw new ArgumentException("minBackgroundColor is not 7 bytes long eg a hex "
+ "RGB value such as #FFFFFF");
}
- bgRMin = HexToInt(minBackgroundColor.Substring(1, 3 - 1));
- bgGMin = HexToInt(minBackgroundColor.Substring(3, 5 - 3));
- bgBMin = HexToInt(minBackgroundColor.Substring(5, 7 - 5));
+ m_bgRMin = HexToInt(minBackgroundColor.Substring(1, 3 - 1));
+ m_bgGMin = HexToInt(minBackgroundColor.Substring(3, 5 - 3));
+ m_bgBMin = HexToInt(minBackgroundColor.Substring(5, 7 - 5));
- bgRMax = HexToInt(maxBackgroundColor.Substring(1, 3 - 1));
- bgGMax = HexToInt(maxBackgroundColor.Substring(3, 5 - 3));
- bgBMax = HexToInt(maxBackgroundColor.Substring(5, 7 - 5));
+ m_bgRMax = HexToInt(maxBackgroundColor.Substring(1, 3 - 1));
+ m_bgGMax = HexToInt(maxBackgroundColor.Substring(3, 5 - 3));
+ m_bgBMax = HexToInt(maxBackgroundColor.Substring(5, 7 - 5));
}
// this.corpusReader = corpusReader;
this.maxScore = maxScore;
@@ -121,13 +121,13 @@ namespace Lucene.Net.Search.Highlight
var sb = new StringBuilder();
sb.Append("<font ");
- if (highlightForeground)
+ if (m_highlightForeground)
{
sb.Append("color=\"");
sb.Append(GetForegroundColorString(score));
sb.Append("\" ");
}
- if (highlightBackground)
+ if (m_highlightBackground)
{
sb.Append("bgcolor=\"");
sb.Append(GetBackgroundColorString(score));
@@ -141,9 +141,9 @@ namespace Lucene.Net.Search.Highlight
protected internal virtual string GetForegroundColorString(float score)
{
- int rVal = GetColorVal(fgRMin, fgRMax, score);
- int gVal = GetColorVal(fgGMin, fgGMax, score);
- int bVal = GetColorVal(fgBMin, fgBMax, score);
+ int rVal = GetColorVal(m_fgRMin, m_fgRMax, score);
+ int gVal = GetColorVal(m_fgGMin, m_fgGMax, score);
+ int bVal = GetColorVal(m_fgBMin, m_fgBMax, score);
var sb = new StringBuilder();
sb.Append("#");
sb.Append(IntToHex(rVal));
@@ -154,9 +154,9 @@ namespace Lucene.Net.Search.Highlight
protected internal virtual string GetBackgroundColorString(float score)
{
- int rVal = GetColorVal(bgRMin, bgRMax, score);
- int gVal = GetColorVal(bgGMin, bgGMax, score);
- int bVal = GetColorVal(bgBMin, bgBMax, score);
+ int rVal = GetColorVal(m_bgRMin, m_bgRMax, score);
+ int gVal = GetColorVal(m_bgGMin, m_bgGMax, score);
+ int bVal = GetColorVal(m_bgBMin, m_bgBMax, score);
var sb = new StringBuilder();
sb.Append("#");
sb.Append(IntToHex(rVal));
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/350040c8/src/Lucene.Net.Highlighter/Highlight/SpanGradientFormatter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Highlighter/Highlight/SpanGradientFormatter.cs b/src/Lucene.Net.Highlighter/Highlight/SpanGradientFormatter.cs
index 731f23f..9a5e42b 100644
--- a/src/Lucene.Net.Highlighter/Highlight/SpanGradientFormatter.cs
+++ b/src/Lucene.Net.Highlighter/Highlight/SpanGradientFormatter.cs
@@ -51,13 +51,13 @@ namespace Lucene.Net.Search.Highlight
var sb = new StringBuilder(originalText.Length + EXTRA);
sb.Append("<span style=\"");
- if (highlightForeground)
+ if (m_highlightForeground)
{
sb.Append("color: ");
sb.Append(GetForegroundColorString(score));
sb.Append("; ");
}
- if (highlightBackground)
+ if (m_highlightBackground)
{
sb.Append("background: ");
sb.Append(GetBackgroundColorString(score));
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/350040c8/src/Lucene.Net.Highlighter/IcuBreakIterator.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Highlighter/IcuBreakIterator.cs b/src/Lucene.Net.Highlighter/IcuBreakIterator.cs
index 5b78790..72e89b0 100644
--- a/src/Lucene.Net.Highlighter/IcuBreakIterator.cs
+++ b/src/Lucene.Net.Highlighter/IcuBreakIterator.cs
@@ -43,12 +43,12 @@ namespace Lucene.Net.Search
/// <summary>
/// The start offset for the string, if supplied by a <see cref="CharacterIterator"/>
/// </summary>
- protected int start;
+ protected int m_start;
/// <summary>
/// The end offset for the string, if supplied by a <see cref="CharacterIterator"/>
/// </summary>
- protected int end;
+ protected int m_end;
public IcuBreakIterator(Icu.BreakIterator.UBreakIteratorType type)
: this(type, CultureInfo.CurrentCulture)
@@ -142,7 +142,7 @@ namespace Lucene.Net.Search
/// <param name="offset"></param>
private void CheckOffset(int offset)
{
- if (offset < start || offset > end)
+ if (offset < m_start || offset > m_end)
{
throw new ArgumentException("offset out of bounds");
}
@@ -262,20 +262,20 @@ namespace Lucene.Net.Search
{
text = newText;
currentBoundaryIndex = 0;
- start = 0;
- end = newText.Length;
+ m_start = 0;
+ m_end = newText.Length;
- LoadBoundaries(start, end);
+ LoadBoundaries(m_start, m_end);
}
public override void SetText(CharacterIterator newText)
{
text = newText.GetTextAsString();
currentBoundaryIndex = 0;
- start = newText.BeginIndex;
- end = newText.EndIndex;
+ m_start = newText.BeginIndex;
+ m_end = newText.EndIndex;
- LoadBoundaries(start, end);
+ LoadBoundaries(m_start, m_end);
}
private void LoadBoundaries(int start, int end)
@@ -333,7 +333,7 @@ namespace Lucene.Net.Search
}
// If there are no boundaries, we must return the start offset
- return start;
+ return m_start;
}
/// <summary>
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/350040c8/src/Lucene.Net.Highlighter/PostingsHighlight/DefaultPassageFormatter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Highlighter/PostingsHighlight/DefaultPassageFormatter.cs b/src/Lucene.Net.Highlighter/PostingsHighlight/DefaultPassageFormatter.cs
index a0bcde0..4538d46 100644
--- a/src/Lucene.Net.Highlighter/PostingsHighlight/DefaultPassageFormatter.cs
+++ b/src/Lucene.Net.Highlighter/PostingsHighlight/DefaultPassageFormatter.cs
@@ -29,13 +29,13 @@ namespace Lucene.Net.Search.PostingsHighlight
public class DefaultPassageFormatter : PassageFormatter
{
/// <summary>text that will appear before highlighted terms</summary>
- protected readonly string preTag;
+ protected readonly string m_preTag;
/// <summary>text that will appear after highlighted terms</summary>
- protected readonly string postTag;
+ protected readonly string m_postTag;
/// <summary>text that will appear between two unconnected passages</summary>
- protected readonly string ellipsis;
+ protected readonly string m_ellipsis;
/// <summary>true if we should escape for html</summary>
- protected readonly bool escape;
+ protected readonly bool m_escape;
/// <summary>
/// Creates a new DefaultPassageFormatter with the default tags.
@@ -58,10 +58,10 @@ namespace Lucene.Net.Search.PostingsHighlight
{
throw new ArgumentException(); //throw new NullPointerException();
}
- this.preTag = preTag;
- this.postTag = postTag;
- this.ellipsis = ellipsis;
- this.escape = escape;
+ this.m_preTag = preTag;
+ this.m_postTag = postTag;
+ this.m_ellipsis = ellipsis;
+ this.m_escape = escape;
}
public override object Format(Passage[] passages, string content)
@@ -73,7 +73,7 @@ namespace Lucene.Net.Search.PostingsHighlight
// don't add ellipsis if its the first one, or if its connected.
if (passage.startOffset > pos && pos > 0)
{
- sb.Append(ellipsis);
+ sb.Append(m_ellipsis);
}
pos = passage.startOffset;
for (int i = 0; i < passage.numMatches; i++)
@@ -87,9 +87,9 @@ namespace Lucene.Net.Search.PostingsHighlight
}
if (end > pos)
{
- sb.Append(preTag);
+ sb.Append(m_preTag);
Append(sb, content, Math.Max(pos, start), end);
- sb.Append(postTag);
+ sb.Append(m_postTag);
pos = end;
}
}
@@ -107,9 +107,9 @@ namespace Lucene.Net.Search.PostingsHighlight
/// <param name="content">original text content</param>
/// <param name="start">index of the first character in content</param>
/// <param name="end">index of the character following the last character in content</param>
- protected virtual void Append(StringBuilder dest, String content, int start, int end)
+ protected virtual void Append(StringBuilder dest, string content, int start, int end)
{
- if (escape)
+ if (m_escape)
{
// note: these are the rules from owasp.org
for (int i = start; i < end; i++)
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/350040c8/src/Lucene.Net.Highlighter/VectorHighlight/BaseFragmentsBuilder.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Highlighter/VectorHighlight/BaseFragmentsBuilder.cs b/src/Lucene.Net.Highlighter/VectorHighlight/BaseFragmentsBuilder.cs
index c8c88cf..696cf7d 100644
--- a/src/Lucene.Net.Highlighter/VectorHighlight/BaseFragmentsBuilder.cs
+++ b/src/Lucene.Net.Highlighter/VectorHighlight/BaseFragmentsBuilder.cs
@@ -38,7 +38,7 @@ namespace Lucene.Net.Search.VectorHighlight
/// </summary>
public abstract class BaseFragmentsBuilder : IFragmentsBuilder
{
- protected string[] preTags, postTags;
+ protected string[] m_preTags, m_postTags;
public static readonly string[] COLORED_PRE_TAGS = {
"<b style=\"background:yellow\">", "<b style=\"background:lawngreen\">", "<b style=\"background:aquamarine\">",
"<b style=\"background:magenta\">", "<b style=\"background:palegreen\">", "<b style=\"background:coral\">",
@@ -70,8 +70,8 @@ namespace Lucene.Net.Search.VectorHighlight
protected BaseFragmentsBuilder(string[] preTags, string[] postTags, IBoundaryScanner boundaryScanner)
{
- this.preTags = preTags;
- this.postTags = postTags;
+ this.m_preTags = preTags;
+ this.m_postTags = postTags;
this.boundaryScanner = boundaryScanner;
}
@@ -90,14 +90,14 @@ namespace Lucene.Net.Search.VectorHighlight
string fieldName, FieldFragList fieldFragList)
{
return CreateFragment(reader, docId, fieldName, fieldFragList,
- preTags, postTags, NULL_ENCODER);
+ m_preTags, m_postTags, NULL_ENCODER);
}
public virtual string[] CreateFragments(IndexReader reader, int docId,
string fieldName, FieldFragList fieldFragList, int maxNumFragments)
{
return CreateFragments(reader, docId, fieldName, fieldFragList, maxNumFragments,
- preTags, postTags, NULL_ENCODER);
+ m_preTags, m_postTags, NULL_ENCODER);
}
public virtual string CreateFragment(IndexReader reader, int docId,
@@ -373,12 +373,12 @@ namespace Lucene.Net.Search.VectorHighlight
protected virtual string GetPreTag(int num)
{
- return GetPreTag(preTags, num);
+ return GetPreTag(m_preTags, num);
}
protected virtual string GetPostTag(int num)
{
- return GetPostTag(postTags, num);
+ return GetPostTag(m_postTags, num);
}
protected virtual string GetPreTag(string[] preTags, int num)
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/350040c8/src/Lucene.Net.Highlighter/VectorHighlight/SimpleBoundaryScanner.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Highlighter/VectorHighlight/SimpleBoundaryScanner.cs b/src/Lucene.Net.Highlighter/VectorHighlight/SimpleBoundaryScanner.cs
index e004525..e16faa1 100644
--- a/src/Lucene.Net.Highlighter/VectorHighlight/SimpleBoundaryScanner.cs
+++ b/src/Lucene.Net.Highlighter/VectorHighlight/SimpleBoundaryScanner.cs
@@ -30,8 +30,8 @@ namespace Lucene.Net.Search.VectorHighlight
public static readonly int DEFAULT_MAX_SCAN = 20;
public static readonly char[] DEFAULT_BOUNDARY_CHARS = { '.', ',', '!', '?', ' ', '\t', '\n' };
- protected int maxScan;
- protected ISet<char> boundaryChars;
+ protected int m_maxScan;
+ protected ISet<char> m_boundaryChars;
public SimpleBoundaryScanner()
: this(DEFAULT_MAX_SCAN, DEFAULT_BOUNDARY_CHARS)
@@ -50,26 +50,26 @@ namespace Lucene.Net.Search.VectorHighlight
public SimpleBoundaryScanner(int maxScan, char[] boundaryChars)
{
- this.maxScan = maxScan;
- this.boundaryChars = new HashSet<char>();
- this.boundaryChars.UnionWith(Arrays.AsList(boundaryChars));
+ this.m_maxScan = maxScan;
+ this.m_boundaryChars = new HashSet<char>();
+ this.m_boundaryChars.UnionWith(Arrays.AsList(boundaryChars));
}
public SimpleBoundaryScanner(int maxScan, ISet<char> boundaryChars)
{
- this.maxScan = maxScan;
- this.boundaryChars = boundaryChars;
+ this.m_maxScan = maxScan;
+ this.m_boundaryChars = boundaryChars;
}
public virtual int FindStartOffset(StringBuilder buffer, int start)
{
// avoid illegal start offset
if (start > buffer.Length || start < 1) return start;
- int offset, count = maxScan;
+ int offset, count = m_maxScan;
for (offset = start; offset > 0 && count > 0; count--)
{
// found?
- if (boundaryChars.Contains(buffer[offset - 1])) return offset;
+ if (m_boundaryChars.Contains(buffer[offset - 1])) return offset;
offset--;
}
// if we scanned up to the start of the text, return it, its a "boundary"
@@ -85,12 +85,12 @@ namespace Lucene.Net.Search.VectorHighlight
{
// avoid illegal start offset
if (start > buffer.Length || start < 0) return start;
- int offset, count = maxScan;
+ int offset, count = m_maxScan;
//for( offset = start; offset <= buffer.length() && count > 0; count-- ){
for (offset = start; offset < buffer.Length && count > 0; count--)
{
// found?
- if (boundaryChars.Contains(buffer[offset])) return offset;
+ if (m_boundaryChars.Contains(buffer[offset])) return offset;
offset++;
}
// not found
[28/28] lucenenet git commit:
Lucene.Net.Analysis.Stempel.Pl.PolishAnalyzer refactor: renamed
GetDefaultStopSet() > DefaultStopSet, GetDefaultTable() > DefaultTable
Posted by ni...@apache.org.
Lucene.Net.Analysis.Stempel.Pl.PolishAnalyzer refactor: renamed GetDefaultStopSet() > DefaultStopSet, GetDefaultTable() > DefaultTable
Project: http://git-wip-us.apache.org/repos/asf/lucenenet/repo
Commit: http://git-wip-us.apache.org/repos/asf/lucenenet/commit/f2e63d35
Tree: http://git-wip-us.apache.org/repos/asf/lucenenet/tree/f2e63d35
Diff: http://git-wip-us.apache.org/repos/asf/lucenenet/diff/f2e63d35
Branch: refs/heads/api-work
Commit: f2e63d354fd34a9dcb55bf812ebe23e5a9a77591
Parents: a332430
Author: Shad Storhaug <sh...@shadstorhaug.com>
Authored: Wed Feb 1 17:12:29 2017 +0700
Committer: Shad Storhaug <sh...@shadstorhaug.com>
Committed: Wed Feb 1 17:12:29 2017 +0700
----------------------------------------------------------------------
src/Lucene.Net.Analysis.Stempel/Pl/PolishAnalyzer.cs | 8 ++++----
.../Stempel/StempelPolishStemFilterFactory.cs | 2 +-
2 files changed, 5 insertions(+), 5 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f2e63d35/src/Lucene.Net.Analysis.Stempel/Pl/PolishAnalyzer.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Analysis.Stempel/Pl/PolishAnalyzer.cs b/src/Lucene.Net.Analysis.Stempel/Pl/PolishAnalyzer.cs
index 60e22ad..acfe570 100644
--- a/src/Lucene.Net.Analysis.Stempel/Pl/PolishAnalyzer.cs
+++ b/src/Lucene.Net.Analysis.Stempel/Pl/PolishAnalyzer.cs
@@ -52,17 +52,17 @@ namespace Lucene.Net.Analysis.Pl
/// Returns an unmodifiable instance of the default stop words set.
/// </summary>
/// <returns>default stop words set.</returns>
- public static CharArraySet GetDefaultStopSet()
+ public static CharArraySet DefaultStopSet
{
- return DefaultsHolder.DEFAULT_STOP_SET;
+ get { return DefaultsHolder.DEFAULT_STOP_SET; }
}
/// <summary>
/// Returns an unmodifiable instance of the default stemmer table.
/// </summary>
- public static Trie GetDefaultTable()
+ public static Trie DefaultTable
{
- return DefaultsHolder.DEFAULT_TABLE;
+ get { return DefaultsHolder.DEFAULT_TABLE; }
}
/// <summary>
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/f2e63d35/src/Lucene.Net.Analysis.Stempel/Stempel/StempelPolishStemFilterFactory.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Analysis.Stempel/Stempel/StempelPolishStemFilterFactory.cs b/src/Lucene.Net.Analysis.Stempel/Stempel/StempelPolishStemFilterFactory.cs
index 759f403..510e87c 100644
--- a/src/Lucene.Net.Analysis.Stempel/Stempel/StempelPolishStemFilterFactory.cs
+++ b/src/Lucene.Net.Analysis.Stempel/Stempel/StempelPolishStemFilterFactory.cs
@@ -42,7 +42,7 @@ namespace Lucene.Net.Analysis.Stempel
public override TokenStream Create(TokenStream input)
{
- return new StempelFilter(input, new StempelStemmer(PolishAnalyzer.GetDefaultTable()));
+ return new StempelFilter(input, new StempelStemmer(PolishAnalyzer.DefaultTable));
}
}
}
[06/28] lucenenet git commit:
Lucene.Net.Misc.Index.Sorter.SortingAtomicReader refactor: changed
IndexOptions enum fields and parameters to be non-nullable
Posted by ni...@apache.org.
Lucene.Net.Misc.Index.Sorter.SortingAtomicReader refactor: changed IndexOptions enum fields and parameters to be non-nullable
Project: http://git-wip-us.apache.org/repos/asf/lucenenet/repo
Commit: http://git-wip-us.apache.org/repos/asf/lucenenet/commit/375e3b6f
Tree: http://git-wip-us.apache.org/repos/asf/lucenenet/tree/375e3b6f
Diff: http://git-wip-us.apache.org/repos/asf/lucenenet/diff/375e3b6f
Branch: refs/heads/api-work
Commit: 375e3b6ffa86b9a0825476a1b432de548a004298
Parents: 366eb42
Author: Shad Storhaug <sh...@shadstorhaug.com>
Authored: Wed Feb 1 13:41:00 2017 +0700
Committer: Shad Storhaug <sh...@shadstorhaug.com>
Committed: Wed Feb 1 13:41:00 2017 +0700
----------------------------------------------------------------------
.../Index/Sorter/SortingAtomicReader.cs | 15 +++++++--------
1 file changed, 7 insertions(+), 8 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/375e3b6f/src/Lucene.Net.Misc/Index/Sorter/SortingAtomicReader.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Misc/Index/Sorter/SortingAtomicReader.cs b/src/Lucene.Net.Misc/Index/Sorter/SortingAtomicReader.cs
index f062fdb..7bce547 100644
--- a/src/Lucene.Net.Misc/Index/Sorter/SortingAtomicReader.cs
+++ b/src/Lucene.Net.Misc/Index/Sorter/SortingAtomicReader.cs
@@ -66,7 +66,7 @@ namespace Lucene.Net.Index.Sorter
}
else
{
- return new SortingTerms(terms, infos.FieldInfo(field).IndexOptions, docMap);
+ return new SortingTerms(terms, infos.FieldInfo(field).IndexOptions.GetValueOrDefault(), docMap);
}
}
}
@@ -75,10 +75,9 @@ namespace Lucene.Net.Index.Sorter
{
internal readonly Sorter.DocMap docMap;
- internal readonly IndexOptions? indexOptions;
+ internal readonly IndexOptions indexOptions;
- // LUCENENET TODO: Make the IndexOptions non nullable
- public SortingTerms(Terms input, IndexOptions? indexOptions, Sorter.DocMap docMap) : base(input)
+ public SortingTerms(Terms input, IndexOptions indexOptions, Sorter.DocMap docMap) : base(input)
{
this.docMap = docMap;
this.indexOptions = indexOptions;
@@ -99,9 +98,9 @@ namespace Lucene.Net.Index.Sorter
{
internal readonly Sorter.DocMap docMap; // pkg-protected to avoid synthetic accessor methods
- internal readonly IndexOptions? indexOptions;
+ internal readonly IndexOptions indexOptions;
- public SortingTermsEnum(TermsEnum @in, Sorter.DocMap docMap, IndexOptions? indexOptions)
+ public SortingTermsEnum(TermsEnum @in, Sorter.DocMap docMap, IndexOptions indexOptions)
: base(@in)
{
this.docMap = docMap;
@@ -159,7 +158,7 @@ namespace Lucene.Net.Index.Sorter
}
DocsEnum inDocs = m_input.Docs(NewToOld(liveDocs), inReuse, flags);
- bool withFreqs = indexOptions.GetValueOrDefault().CompareTo(IndexOptions.DOCS_AND_FREQS) >= 0 && (flags & DocsEnum.FLAG_FREQS) != 0;
+ bool withFreqs = indexOptions.CompareTo(IndexOptions.DOCS_AND_FREQS) >= 0 && (flags & DocsEnum.FLAG_FREQS) != 0;
return new SortingDocsEnum(docMap.Count, wrapReuse, inDocs, withFreqs, docMap);
}
@@ -190,7 +189,7 @@ namespace Lucene.Net.Index.Sorter
// since this code is expected to be used during addIndexes which will
// ask for everything. if that assumption changes in the future, we can
// factor in whether 'flags' says offsets are not required.
- bool storeOffsets = indexOptions.GetValueOrDefault().CompareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS) >= 0;
+ bool storeOffsets = indexOptions.CompareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS) >= 0;
return new SortingDocsAndPositionsEnum(docMap.Count, wrapReuse, inDocsAndPositions, docMap, storeOffsets);
}
}
[08/28] lucenenet git commit: Lucene.Net.Tests.Memory: added API
consistency tests
Posted by ni...@apache.org.
Lucene.Net.Tests.Memory: added API consistency tests
Project: http://git-wip-us.apache.org/repos/asf/lucenenet/repo
Commit: http://git-wip-us.apache.org/repos/asf/lucenenet/commit/9ccf3f0d
Tree: http://git-wip-us.apache.org/repos/asf/lucenenet/tree/9ccf3f0d
Diff: http://git-wip-us.apache.org/repos/asf/lucenenet/diff/9ccf3f0d
Branch: refs/heads/api-work
Commit: 9ccf3f0d5c72506dccb340c6e8251f9dfc7e9ad5
Parents: a7dae6e
Author: Shad Storhaug <sh...@shadstorhaug.com>
Authored: Wed Feb 1 13:46:56 2017 +0700
Committer: Shad Storhaug <sh...@shadstorhaug.com>
Committed: Wed Feb 1 13:46:56 2017 +0700
----------------------------------------------------------------------
.../Lucene.Net.Tests.Memory.csproj | 1 +
.../TestApiConsistency.cs | 120 +++++++++++++++++++
2 files changed, 121 insertions(+)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9ccf3f0d/src/Lucene.Net.Tests.Memory/Lucene.Net.Tests.Memory.csproj
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Memory/Lucene.Net.Tests.Memory.csproj b/src/Lucene.Net.Tests.Memory/Lucene.Net.Tests.Memory.csproj
index 568504c..e10bc23 100644
--- a/src/Lucene.Net.Tests.Memory/Lucene.Net.Tests.Memory.csproj
+++ b/src/Lucene.Net.Tests.Memory/Lucene.Net.Tests.Memory.csproj
@@ -42,6 +42,7 @@
<ItemGroup>
<Compile Include="Index\Memory\MemoryIndexTest.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />
+ <Compile Include="TestApiConsistency.cs" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\Lucene.Net.Core\Lucene.Net.csproj">
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9ccf3f0d/src/Lucene.Net.Tests.Memory/TestApiConsistency.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Memory/TestApiConsistency.cs b/src/Lucene.Net.Tests.Memory/TestApiConsistency.cs
new file mode 100644
index 0000000..7927969
--- /dev/null
+++ b/src/Lucene.Net.Tests.Memory/TestApiConsistency.cs
@@ -0,0 +1,120 @@
+\ufeffusing Lucene.Net.Attributes;
+using Lucene.Net.Util;
+using NUnit.Framework;
+using System;
+
+namespace Lucene.Net.Tests.Memory
+{
+ /// <summary>
+ /// LUCENENET specific tests for ensuring API conventions are followed
+ /// </summary>
+ public class TestApiConsistency : ApiScanTestBase
+ {
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Index.Memory.MemoryIndex))]
+ public override void TestProtectedFieldNames(Type typeFromTargetAssembly)
+ {
+ base.TestProtectedFieldNames(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Index.Memory.MemoryIndex))]
+ public override void TestPrivateFieldNames(Type typeFromTargetAssembly)
+ {
+ base.TestPrivateFieldNames(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Index.Memory.MemoryIndex))]
+ public override void TestPublicFields(Type typeFromTargetAssembly)
+ {
+ base.TestPublicFields(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Index.Memory.MemoryIndex))]
+ public override void TestMethodParameterNames(Type typeFromTargetAssembly)
+ {
+ base.TestMethodParameterNames(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Index.Memory.MemoryIndex))]
+ public override void TestInterfaceNames(Type typeFromTargetAssembly)
+ {
+ base.TestInterfaceNames(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Index.Memory.MemoryIndex))]
+ public override void TestClassNames(Type typeFromTargetAssembly)
+ {
+ base.TestClassNames(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Index.Memory.MemoryIndex))]
+ public override void TestForPropertiesWithNoGetter(Type typeFromTargetAssembly)
+ {
+ base.TestForPropertiesWithNoGetter(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Index.Memory.MemoryIndex))]
+ public override void TestForPropertiesThatReturnArray(Type typeFromTargetAssembly)
+ {
+ base.TestForPropertiesThatReturnArray(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Index.Memory.MemoryIndex))]
+ public override void TestForMethodsThatReturnWritableArray(Type typeFromTargetAssembly)
+ {
+ base.TestForMethodsThatReturnWritableArray(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Index.Memory.MemoryIndex))]
+ public override void TestForPublicMembersContainingComparer(Type typeFromTargetAssembly)
+ {
+ base.TestForPublicMembersContainingComparer(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Index.Memory.MemoryIndex))]
+ public override void TestForPublicMembersNamedSize(Type typeFromTargetAssembly)
+ {
+ base.TestForPublicMembersNamedSize(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Index.Memory.MemoryIndex))]
+ public override void TestForPublicMembersContainingNonNetNumeric(Type typeFromTargetAssembly)
+ {
+ base.TestForPublicMembersContainingNonNetNumeric(typeFromTargetAssembly);
+ }
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Index.Memory.MemoryIndex))]
+ public override void TestForPublicMembersWithNullableEnum(Type typeFromTargetAssembly)
+ {
+ base.TestForPublicMembersWithNullableEnum(typeFromTargetAssembly);
+ }
+
+ // LUCENENET NOTE: This test is only for identifying members who were changed from
+ // ICollection, IList or ISet to IEnumerable during the port (that should be changed back)
+ //[Test, LuceneNetSpecific]
+ //[TestCase(typeof(Lucene.Net.Index.Memory.MemoryIndex))]
+ //public override void TestForMembersAcceptingOrReturningIEnumerable(Type typeFromTargetAssembly)
+ //{
+ // base.TestForMembersAcceptingOrReturningIEnumerable(typeFromTargetAssembly);
+ //}
+
+ [Test, LuceneNetSpecific]
+ [TestCase(typeof(Lucene.Net.Index.Memory.MemoryIndex))]
+ public override void TestForMembersAcceptingOrReturningListOrDictionary(Type typeFromTargetAssembly)
+ {
+ base.TestForMembersAcceptingOrReturningListOrDictionary(typeFromTargetAssembly);
+ }
+ }
+}
[19/28] lucenenet git commit:
Lucene.Net.Grouping.AbstractAllGroupHeadsCollector refactor: renamed
GroupHeadsSize > GroupHeadsCount
Posted by ni...@apache.org.
Lucene.Net.Grouping.AbstractAllGroupHeadsCollector refactor: renamed GroupHeadsSize > GroupHeadsCount
Project: http://git-wip-us.apache.org/repos/asf/lucenenet/repo
Commit: http://git-wip-us.apache.org/repos/asf/lucenenet/commit/3a4c23e9
Tree: http://git-wip-us.apache.org/repos/asf/lucenenet/tree/3a4c23e9
Diff: http://git-wip-us.apache.org/repos/asf/lucenenet/diff/3a4c23e9
Branch: refs/heads/api-work
Commit: 3a4c23e973ff869dea6ddb46d08fe3b0f9a77a18
Parents: 378f1f1
Author: Shad Storhaug <sh...@shadstorhaug.com>
Authored: Wed Feb 1 16:29:28 2017 +0700
Committer: Shad Storhaug <sh...@shadstorhaug.com>
Committed: Wed Feb 1 16:29:28 2017 +0700
----------------------------------------------------------------------
src/Lucene.Net.Grouping/AbstractAllGroupHeadsCollector.cs | 10 ++++++----
1 file changed, 6 insertions(+), 4 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/3a4c23e9/src/Lucene.Net.Grouping/AbstractAllGroupHeadsCollector.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Grouping/AbstractAllGroupHeadsCollector.cs b/src/Lucene.Net.Grouping/AbstractAllGroupHeadsCollector.cs
index 2fb3d59..3f6d46b 100644
--- a/src/Lucene.Net.Grouping/AbstractAllGroupHeadsCollector.cs
+++ b/src/Lucene.Net.Grouping/AbstractAllGroupHeadsCollector.cs
@@ -78,10 +78,11 @@ namespace Lucene.Net.Search.Grouping
}
/// <summary>
- ///
+ /// The number of group heads found for a query.
+ /// LUCENENET NOTE: This was groupHeadsSize() in Lucene
/// </summary>
/// <returns>the number of group heads found for a query.</returns>
- public override int GroupHeadsSize
+ public override int GroupHeadsCount
{
get
{
@@ -225,10 +226,11 @@ namespace Lucene.Net.Search.Grouping
public abstract int[] RetrieveGroupHeads();
/// <summary>
- ///
+ /// The number of group heads found for a query.
+ /// LUCENENET NOTE: This was groupHeadsSize() in Lucene
/// </summary>
/// <returns>the number of group heads found for a query.</returns>
- public abstract int GroupHeadsSize { get; } // LUCENENET TODO: Rename GroupHeadsCount ?
+ public abstract int GroupHeadsCount { get; }
/// <summary>
/// Returns the group head and puts it into <see cref="TemporalResult"/>.