lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From nightowl...@apache.org
Subject [16/28] lucenenet git commit: Lucene.Net.Grouping refactor: renamed all protected fields camelCase prefixed with m_
Date Wed, 01 Feb 2017 10:22:13 GMT
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 <shad@shadstorhaug.com>
Authored: Wed Feb 1 14:20:57 2017 +0700
Committer: Shad Storhaug <shad@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;
         }


Mime
View raw message