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 <[email protected]> Authored: Wed Feb 1 14:20:57 2017 +0700 Committer: Shad Storhaug <[email protected]> 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; }
