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:22:13 UTC
[16/28] lucenenet git commit: Lucene.Net.Grouping refactor: renamed
all protected fields camelCase prefixed with m_
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;
}