lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From nightowl...@apache.org
Subject [35/53] [abbrv] lucenenet git commit: Lucene.Net.Facet: Renamed all type-derived classes and interfaces from Short, Int, Long, and Float to match CLR types Int16, Int32, Int64, and Single, respectively.
Date Wed, 08 Feb 2017 14:32:14 GMT
Lucene.Net.Facet: Renamed all type-derived classes and interfaces from Short, Int, Long, and Float to match CLR types Int16, Int32, Int64, and Single, respectively.


Project: http://git-wip-us.apache.org/repos/asf/lucenenet/repo
Commit: http://git-wip-us.apache.org/repos/asf/lucenenet/commit/c3485316
Tree: http://git-wip-us.apache.org/repos/asf/lucenenet/tree/c3485316
Diff: http://git-wip-us.apache.org/repos/asf/lucenenet/diff/c3485316

Branch: refs/heads/api-work
Commit: c34853169551552110c399f150eadf7e89bb8527
Parents: d3dfb95
Author: Shad Storhaug <shad@shadstorhaug.com>
Authored: Wed Feb 8 02:50:32 2017 +0700
Committer: Shad Storhaug <shad@shadstorhaug.com>
Committed: Wed Feb 8 21:08:23 2017 +0700

----------------------------------------------------------------------
 src/Lucene.Net.Facet/FacetsConfig.cs            |  8 ++---
 src/Lucene.Net.Facet/Range/DoubleRange.cs       |  4 +--
 .../Range/DoubleRangeFacetCounts.cs             |  6 ++--
 src/Lucene.Net.Facet/Range/LongRange.cs         | 14 ++++----
 src/Lucene.Net.Facet/Range/LongRangeCounter.cs  | 36 +++++++++++---------
 .../Range/LongRangeFacetCounts.cs               | 25 +++++++-------
 .../SortedSet/SortedSetDocValuesFacetCounts.cs  | 10 +++---
 .../Taxonomy/AssociationFacetField.cs           |  4 +--
 src/Lucene.Net.Facet/Taxonomy/FacetLabel.cs     |  4 +--
 .../Taxonomy/FastTaxonomyFacetCounts.cs         |  2 +-
 .../Taxonomy/FloatAssociationFacetField.cs      | 16 +++++----
 .../Taxonomy/FloatTaxonomyFacets.cs             | 16 +++++----
 .../Taxonomy/IntAssociationFacetField.cs        |  8 +++--
 .../Taxonomy/IntTaxonomyFacets.cs               | 17 ++++-----
 .../Taxonomy/TaxonomyFacetCounts.cs             |  2 +-
 .../TaxonomyFacetSumFloatAssociations.cs        | 16 +++++----
 .../Taxonomy/TaxonomyFacetSumIntAssociations.cs | 16 +++++----
 .../Taxonomy/TaxonomyFacetSumValueSource.cs     |  2 +-
 .../WriterCache/LruTaxonomyWriterCache.cs       |  6 ++--
 .../Taxonomy/WriterCache/NameHashIntCacheLRU.cs |  8 +++--
 .../Taxonomy/WriterCache/NameIntCacheLRU.cs     |  6 ++--
 src/Lucene.Net.Facet/TopOrdAndFloatQueue.cs     | 10 +++---
 src/Lucene.Net.Facet/TopOrdAndIntQueue.cs       | 10 +++---
 .../Range/TestRangeFacetCounts.cs               | 26 +++++++-------
 .../Taxonomy/TestFacetLabel.cs                  | 12 +++----
 .../Taxonomy/TestTaxonomyFacetAssociations.cs   | 28 +++++++--------
 26 files changed, 169 insertions(+), 143 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c3485316/src/Lucene.Net.Facet/FacetsConfig.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/FacetsConfig.cs b/src/Lucene.Net.Facet/FacetsConfig.cs
index 61fe046..ae6775d 100644
--- a/src/Lucene.Net.Facet/FacetsConfig.cs
+++ b/src/Lucene.Net.Facet/FacetsConfig.cs
@@ -32,10 +32,10 @@ namespace Lucene.Net.Facet
     using Document = Lucene.Net.Documents.Document;
     using FacetLabel = Lucene.Net.Facet.Taxonomy.FacetLabel;
     using Field = Lucene.Net.Documents.Field;
-    using FloatAssociationFacetField = Lucene.Net.Facet.Taxonomy.FloatAssociationFacetField;
+    using SingleAssociationFacetField = Lucene.Net.Facet.Taxonomy.SingleAssociationFacetField;
     using IIndexableField = Lucene.Net.Index.IIndexableField;
     using IIndexableFieldType = Lucene.Net.Index.IIndexableFieldType;
-    using IntAssociationFacetField = Lucene.Net.Facet.Taxonomy.IntAssociationFacetField;
+    using Int32AssociationFacetField = Lucene.Net.Facet.Taxonomy.Int32AssociationFacetField;
     using Int32sRef = Lucene.Net.Util.Int32sRef;
     using SortedSetDocValuesFacetField = Lucene.Net.Facet.SortedSet.SortedSetDocValuesFacetField;
     using SortedSetDocValuesField = Lucene.Net.Documents.SortedSetDocValuesField;
@@ -357,11 +357,11 @@ namespace Lucene.Net.Facet
                     // Best effort: detect mis-matched types in same
                     // indexed field:
                     string type;
-                    if (facetField is IntAssociationFacetField)
+                    if (facetField is Int32AssociationFacetField)
                     {
                         type = "int";
                     }
-                    else if (facetField is FloatAssociationFacetField)
+                    else if (facetField is SingleAssociationFacetField)
                     {
                         type = "float";
                     }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c3485316/src/Lucene.Net.Facet/Range/DoubleRange.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Range/DoubleRange.cs b/src/Lucene.Net.Facet/Range/DoubleRange.cs
index c8201bc..ed17c23 100644
--- a/src/Lucene.Net.Facet/Range/DoubleRange.cs
+++ b/src/Lucene.Net.Facet/Range/DoubleRange.cs
@@ -108,9 +108,9 @@ namespace Lucene.Net.Facet.Range
         /// <summary>
         /// NOTE: This was toLongRange() in Lucene
         /// </summary>
-        internal LongRange ToInt64Range()
+        internal Int64Range ToInt64Range()
         {
-            return new LongRange(Label, NumericUtils.DoubleToSortableInt64(minIncl), true, NumericUtils.DoubleToSortableInt64(maxIncl), true);
+            return new Int64Range(Label, NumericUtils.DoubleToSortableInt64(minIncl), true, NumericUtils.DoubleToSortableInt64(maxIncl), true);
         }
 
         public override string ToString()

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c3485316/src/Lucene.Net.Facet/Range/DoubleRangeFacetCounts.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Range/DoubleRangeFacetCounts.cs b/src/Lucene.Net.Facet/Range/DoubleRangeFacetCounts.cs
index bf9c03e..efcfbcf 100644
--- a/src/Lucene.Net.Facet/Range/DoubleRangeFacetCounts.cs
+++ b/src/Lucene.Net.Facet/Range/DoubleRangeFacetCounts.cs
@@ -87,14 +87,14 @@ namespace Lucene.Net.Facet.Range
 
             DoubleRange[] ranges = (DoubleRange[])this.m_ranges;
 
-            LongRange[] longRanges = new LongRange[ranges.Length];
+            Int64Range[] longRanges = new Int64Range[ranges.Length];
             for (int i = 0; i < ranges.Length; i++)
             {
                 DoubleRange range = ranges[i];
-                longRanges[i] = new LongRange(range.Label, NumericUtils.DoubleToSortableInt64(range.minIncl), true, NumericUtils.DoubleToSortableInt64(range.maxIncl), true);
+                longRanges[i] = new Int64Range(range.Label, NumericUtils.DoubleToSortableInt64(range.minIncl), true, NumericUtils.DoubleToSortableInt64(range.maxIncl), true);
             }
 
-            LongRangeCounter counter = new LongRangeCounter(longRanges);
+            Int64RangeCounter counter = new Int64RangeCounter(longRanges);
 
             int missingCount = 0;
             foreach (MatchingDocs hits in matchingDocs)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c3485316/src/Lucene.Net.Facet/Range/LongRange.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Range/LongRange.cs b/src/Lucene.Net.Facet/Range/LongRange.cs
index 8267328..ac75ef6 100644
--- a/src/Lucene.Net.Facet/Range/LongRange.cs
+++ b/src/Lucene.Net.Facet/Range/LongRange.cs
@@ -28,11 +28,13 @@ namespace Lucene.Net.Facet.Range
     using ValueSource = Lucene.Net.Queries.Function.ValueSource;
 
     /// <summary>
-    /// Represents a range over long values.
+    /// Represents a range over <see cref="long"/> values.
+    /// <para/>
+    /// NOTE: This was LongRange in Lucene
     /// 
     /// @lucene.experimental 
     /// </summary>
-    public sealed class LongRange : Range
+    public sealed class Int64Range : Range
     {
         internal readonly long minIncl;
         internal readonly long maxIncl;
@@ -57,8 +59,8 @@ namespace Lucene.Net.Facet.Range
         // Double/FloatRange too)
 
         /// <summary>
-        /// Create a LongRange. </summary>
-        public LongRange(string label, long minIn, bool minInclusive, long maxIn, bool maxInclusive)
+        /// Create a <see cref="Int64Range"/>. </summary>
+        public Int64Range(string label, long minIn, bool minInclusive, long maxIn, bool maxInclusive)
             : base(label)
         {
             this.Min = minIn;
@@ -118,12 +120,12 @@ namespace Lucene.Net.Facet.Range
 
         private class FilterAnonymousInnerClassHelper : Filter
         {
-            private readonly LongRange outerInstance;
+            private readonly Int64Range outerInstance;
 
             private readonly Filter fastMatchFilter;
             private readonly ValueSource valueSource;
 
-            public FilterAnonymousInnerClassHelper(LongRange outerInstance, Filter fastMatchFilter, ValueSource valueSource)
+            public FilterAnonymousInnerClassHelper(Int64Range outerInstance, Filter fastMatchFilter, ValueSource valueSource)
             {
                 this.outerInstance = outerInstance;
                 this.fastMatchFilter = fastMatchFilter;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c3485316/src/Lucene.Net.Facet/Range/LongRangeCounter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Range/LongRangeCounter.cs b/src/Lucene.Net.Facet/Range/LongRangeCounter.cs
index b6581b3..02cddec 100644
--- a/src/Lucene.Net.Facet/Range/LongRangeCounter.cs
+++ b/src/Lucene.Net.Facet/Range/LongRangeCounter.cs
@@ -25,11 +25,13 @@ namespace Lucene.Net.Facet.Range
     /// Counts how many times each range was seen;
     /// per-hit it's just a binary search (<see cref="Add"/>)
     /// against the elementary intervals, and in the end we
-    /// rollup back to the original ranges. 
+    /// rollup back to the original ranges.
+    /// <para/>
+    /// NOTE: This was LongRangeCounter in Lucene
     /// </summary>
-    internal sealed class LongRangeCounter
+    internal sealed class Int64RangeCounter
     {
-        internal readonly LongRangeNode root;
+        internal readonly Int64RangeNode root;
         internal readonly long[] boundaries;
         internal readonly int[] leafCounts;
 
@@ -37,7 +39,7 @@ namespace Lucene.Net.Facet.Range
         private int leafUpto;
         private int missingCount;
 
-        public LongRangeCounter(LongRange[] ranges)
+        public Int64RangeCounter(Int64Range[] ranges)
         {
             // Maps all range inclusive endpoints to int flags; 1
             // = start of interval, 2 = end of interval.  We need to
@@ -49,7 +51,7 @@ namespace Lucene.Net.Facet.Range
             endsMap[long.MinValue] = 1;
             endsMap[long.MaxValue] = 2;
 
-            foreach (LongRange range in ranges)
+            foreach (Int64Range range in ranges)
             {
                 int? cur;
                 if (!endsMap.TryGetValue(range.minIncl, out cur))
@@ -216,7 +218,7 @@ namespace Lucene.Net.Facet.Range
             return missingCount;
         }
 
-        private int Rollup(LongRangeNode node, int[] counts, bool sawOutputs)
+        private int Rollup(Int64RangeNode node, int[] counts, bool sawOutputs)
         {
             int count;
             sawOutputs |= node.outputs != null;
@@ -248,20 +250,20 @@ namespace Lucene.Net.Facet.Range
             return count;
         }
 
-        private static LongRangeNode Split(int start, int end, IList<InclusiveRange> elementaryIntervals)
+        private static Int64RangeNode Split(int start, int end, IList<InclusiveRange> elementaryIntervals)
         {
             if (start == end - 1)
             {
                 // leaf
                 InclusiveRange range = elementaryIntervals[start];
-                return new LongRangeNode(range.Start, range.End, null, null, start);
+                return new Int64RangeNode(range.Start, range.End, null, null, start);
             }
             else
             {
                 int mid = (int)((uint)(start + end) >> 1);
-                LongRangeNode left = Split(start, mid, elementaryIntervals);
-                LongRangeNode right = Split(mid, end, elementaryIntervals);
-                return new LongRangeNode(left.start, right.end, left, right, -1);
+                Int64RangeNode left = Split(start, mid, elementaryIntervals);
+                Int64RangeNode right = Split(mid, end, elementaryIntervals);
+                return new Int64RangeNode(left.start, right.end, left, right, -1);
             }
         }
 
@@ -285,11 +287,13 @@ namespace Lucene.Net.Facet.Range
 
         /// <summary>
         /// Holds one node of the segment tree.
+        /// <para/>
+        /// NOTE: This was LongRangeNode in Lucene
         /// </summary>
-        public sealed class LongRangeNode
+        public sealed class Int64RangeNode
         {
-            internal readonly LongRangeNode left;
-            internal readonly LongRangeNode right;
+            internal readonly Int64RangeNode left;
+            internal readonly Int64RangeNode right;
 
             // Our range, inclusive:
             internal readonly long start;
@@ -303,7 +307,7 @@ namespace Lucene.Net.Facet.Range
             // through this node:
             internal IList<int?> outputs;
 
-            public LongRangeNode(long start, long end, LongRangeNode left, LongRangeNode right, int leafIndex)
+            public Int64RangeNode(long start, long end, Int64RangeNode left, Int64RangeNode right, int leafIndex)
             {
                 this.start = start;
                 this.end = end;
@@ -330,7 +334,7 @@ namespace Lucene.Net.Facet.Range
             /// <summary>
             /// Recursively assigns range outputs to each node.
             /// </summary>
-            internal void AddOutputs(int index, LongRange range)
+            internal void AddOutputs(int index, Int64Range range)
             {
                 if (start >= range.minIncl && end <= range.maxIncl)
                 {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c3485316/src/Lucene.Net.Facet/Range/LongRangeFacetCounts.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Range/LongRangeFacetCounts.cs b/src/Lucene.Net.Facet/Range/LongRangeFacetCounts.cs
index 81debc7..4f80fba 100644
--- a/src/Lucene.Net.Facet/Range/LongRangeFacetCounts.cs
+++ b/src/Lucene.Net.Facet/Range/LongRangeFacetCounts.cs
@@ -36,40 +36,41 @@ namespace Lucene.Net.Facet.Range
     /// relative time based dimension like "Past day", "Past 2
     /// days", etc.) or that change for each request (e.g. 
     /// distance from the user's location, "&lt; 1 km", "&lt; 2 km",
-    ///  etc.).
+    /// etc.).
+    /// <para/>
+    /// NOTE: This was LongRangeFacetCounts in Lucene
     /// 
     ///  @lucene.experimental 
     /// </summary>
-    public class LongRangeFacetCounts : RangeFacetCounts
+    public class Int64RangeFacetCounts : RangeFacetCounts
     {
-
         /// <summary>
-        /// Create <see cref="LongRangeFacetCounts"/>, using
+        /// Create <see cref="Int64RangeFacetCounts"/>, using
         /// <see cref="LongFieldSource"/> from the specified field. 
         /// </summary>
-        public LongRangeFacetCounts(string field, FacetsCollector hits, params LongRange[] ranges)
+        public Int64RangeFacetCounts(string field, FacetsCollector hits, params Int64Range[] ranges)
             : this(field, new LongFieldSource(field), hits, ranges)
         {
         }
 
         /// <summary>
-        /// Create <see cref="RangeFacetCounts"/>, using the provided
+        /// Create <see cref="Int64RangeFacetCounts"/>, using the provided
         /// <see cref="ValueSource"/>. 
         /// </summary>
-        public LongRangeFacetCounts(string field, ValueSource valueSource, FacetsCollector hits, params LongRange[] ranges)
+        public Int64RangeFacetCounts(string field, ValueSource valueSource, FacetsCollector hits, params Int64Range[] ranges)
             : this(field, valueSource, hits, null, ranges)
         {
         }
 
         /// <summary>
-        /// Create <see cref="RangeFacetCounts"/>, using the provided
+        /// Create <see cref="Int64RangeFacetCounts"/>, using the provided
         /// <see cref="ValueSource"/>, and using the provided Filter as
         /// a fastmatch: only documents passing the filter are
         /// checked for the matching ranges.  The filter must be
         /// random access (implement <see cref="DocIdSet.Bits"/>). 
         /// </summary>
-        public LongRangeFacetCounts(string field, ValueSource valueSource, 
-            FacetsCollector hits, Filter fastMatchFilter, params LongRange[] ranges)
+        public Int64RangeFacetCounts(string field, ValueSource valueSource, 
+            FacetsCollector hits, Filter fastMatchFilter, params Int64Range[] ranges)
             : base(field, ranges, fastMatchFilter)
         {
             Count(valueSource, hits.GetMatchingDocs());
@@ -78,9 +79,9 @@ namespace Lucene.Net.Facet.Range
         private void Count(ValueSource valueSource, IList<MatchingDocs> matchingDocs)
         {
 
-            LongRange[] ranges = (LongRange[])this.m_ranges;
+            Int64Range[] ranges = (Int64Range[])this.m_ranges;
 
-            LongRangeCounter counter = new LongRangeCounter(ranges);
+            Int64RangeCounter counter = new Int64RangeCounter(ranges);
 
             int missingCount = 0;
             foreach (MatchingDocs hits in matchingDocs)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c3485316/src/Lucene.Net.Facet/SortedSet/SortedSetDocValuesFacetCounts.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/SortedSet/SortedSetDocValuesFacetCounts.cs b/src/Lucene.Net.Facet/SortedSet/SortedSetDocValuesFacetCounts.cs
index 5e1d0b5..bd385f0 100644
--- a/src/Lucene.Net.Facet/SortedSet/SortedSetDocValuesFacetCounts.cs
+++ b/src/Lucene.Net.Facet/SortedSet/SortedSetDocValuesFacetCounts.cs
@@ -92,14 +92,14 @@ namespace Lucene.Net.Facet.SortedSet
 
         private FacetResult GetDim(string dim, OrdRange ordRange, int topN)
         {
-            TopOrdAndIntQueue q = null;
+            TopOrdAndInt32Queue q = null;
 
             int bottomCount = 0;
 
             int dimCount = 0;
             int childCount = 0;
 
-            TopOrdAndIntQueue.OrdAndValue reuse = null;
+            TopOrdAndInt32Queue.OrdAndValue reuse = null;
             //System.out.println("getDim : " + ordRange.start + " - " + ordRange.end);
             for (int ord = ordRange.Start; ord <= ordRange.End; ord++)
             {
@@ -112,7 +112,7 @@ namespace Lucene.Net.Facet.SortedSet
                     {
                         if (reuse == null)
                         {
-                            reuse = new TopOrdAndIntQueue.OrdAndValue();
+                            reuse = new TopOrdAndInt32Queue.OrdAndValue();
                         }
                         reuse.Ord = ord;
                         reuse.Value = counts[ord];
@@ -120,7 +120,7 @@ namespace Lucene.Net.Facet.SortedSet
                         {
                             // Lazy init, so we don't create this for the
                             // sparse case unnecessarily
-                            q = new TopOrdAndIntQueue(topN);
+                            q = new TopOrdAndInt32Queue(topN);
                         }
                         reuse = q.InsertWithOverflow(reuse);
                         if (q.Count == topN)
@@ -139,7 +139,7 @@ namespace Lucene.Net.Facet.SortedSet
             LabelAndValue[] labelValues = new LabelAndValue[q.Count];
             for (int i = labelValues.Length - 1; i >= 0; i--)
             {
-                TopOrdAndIntQueue.OrdAndValue ordAndValue = q.Pop();
+                TopOrdAndInt32Queue.OrdAndValue ordAndValue = q.Pop();
                 var term = new BytesRef();
                 dv.LookupOrd(ordAndValue.Ord, term);
                 string[] parts = FacetsConfig.StringToPath(term.Utf8ToString());

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c3485316/src/Lucene.Net.Facet/Taxonomy/AssociationFacetField.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/AssociationFacetField.cs b/src/Lucene.Net.Facet/Taxonomy/AssociationFacetField.cs
index 1e4731f..5085ea1 100644
--- a/src/Lucene.Net.Facet/Taxonomy/AssociationFacetField.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/AssociationFacetField.cs
@@ -29,8 +29,8 @@ namespace Lucene.Net.Facet.Taxonomy
     /// Add an instance of this to your <see cref="Document"/> to add
     /// a facet label associated with an arbitrary <see cref="T:byte[]"/>.
     /// This will require a custom <see cref="Facets"/>
-    /// implementation at search time; see <see cref="IntAssociationFacetField"/> 
-    /// and <see cref="FloatAssociationFacetField"/> to use existing 
+    /// implementation at search time; see <see cref="Int32AssociationFacetField"/> 
+    /// and <see cref="SingleAssociationFacetField"/> to use existing 
     /// <see cref="Facets"/> implementations.
     /// 
     ///  @lucene.experimental 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c3485316/src/Lucene.Net.Facet/Taxonomy/FacetLabel.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/FacetLabel.cs b/src/Lucene.Net.Facet/Taxonomy/FacetLabel.cs
index 1a54c0d..4904eec 100644
--- a/src/Lucene.Net.Facet/Taxonomy/FacetLabel.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/FacetLabel.cs
@@ -23,7 +23,7 @@ namespace Lucene.Net.Facet.Taxonomy
      */
 
     using LruTaxonomyWriterCache = Lucene.Net.Facet.Taxonomy.WriterCache.LruTaxonomyWriterCache;
-    using NameHashIntCacheLRU = Lucene.Net.Facet.Taxonomy.WriterCache.NameHashIntCacheLRU;
+    using NameHashInt32CacheLRU = Lucene.Net.Facet.Taxonomy.WriterCache.NameHashInt32CacheLRU;
 
     /// <summary>
     /// Holds a sequence of string components, specifying the hierarchical name of a
@@ -177,7 +177,7 @@ namespace Lucene.Net.Facet.Taxonomy
 
         /// <summary>
         /// Calculate a 64-bit hash function for this path.  This
-        /// is necessary for <see cref="NameHashIntCacheLRU"/> (the
+        /// is necessary for <see cref="NameHashInt32CacheLRU"/> (the
         /// default cache impl for <see cref="LruTaxonomyWriterCache"/>) 
         /// to reduce the chance of "silent but deadly" collisions.
         /// <para/>

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c3485316/src/Lucene.Net.Facet/Taxonomy/FastTaxonomyFacetCounts.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/FastTaxonomyFacetCounts.cs b/src/Lucene.Net.Facet/Taxonomy/FastTaxonomyFacetCounts.cs
index 44909ca..26713ea 100644
--- a/src/Lucene.Net.Facet/Taxonomy/FastTaxonomyFacetCounts.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/FastTaxonomyFacetCounts.cs
@@ -30,7 +30,7 @@ namespace Lucene.Net.Facet.Taxonomy
     /// 
     /// @lucene.experimental 
     /// </summary>
-    public class FastTaxonomyFacetCounts : IntTaxonomyFacets
+    public class FastTaxonomyFacetCounts : Int32TaxonomyFacets
     {
         /// <summary>
         /// Create <see cref="FastTaxonomyFacetCounts"/>, which also

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c3485316/src/Lucene.Net.Facet/Taxonomy/FloatAssociationFacetField.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/FloatAssociationFacetField.cs b/src/Lucene.Net.Facet/Taxonomy/FloatAssociationFacetField.cs
index 1257ff6..8595a0f 100644
--- a/src/Lucene.Net.Facet/Taxonomy/FloatAssociationFacetField.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/FloatAssociationFacetField.cs
@@ -25,18 +25,20 @@ namespace Lucene.Net.Facet.Taxonomy
 
     /// <summary>
     /// Add an instance of this to your <see cref="Document"/> to add
-    /// a facet label associated with a float.  Use <see cref="TaxonomyFacetSumFloatAssociations"/>
-    /// to aggregate float values per facet label at search time.
+    /// a facet label associated with a <see cref="float"/>.  Use <see cref="TaxonomyFacetSumSingleAssociations"/>
+    /// to aggregate <see cref="float"/> values per facet label at search time.
+    /// <para/>
+    /// NOTE: This was FloatAssociationFacetField in Lucene
     /// 
     ///  @lucene.experimental 
     /// </summary>
-    public class FloatAssociationFacetField : AssociationFacetField
+    public class SingleAssociationFacetField : AssociationFacetField
     {
         /// <summary>
         /// Creates this from <paramref name="dim"/> and <paramref name="path"/> and a
-        /// float association 
+        /// <see cref="float"/> association 
         /// </summary>
-        public FloatAssociationFacetField(float assoc, string dim, params string[] path) 
+        public SingleAssociationFacetField(float assoc, string dim, params string[] path) 
             : base(SingleToBytesRef(assoc), dim, path)
         {
         }
@@ -48,7 +50,7 @@ namespace Lucene.Net.Facet.Taxonomy
         /// </summary>
         public static BytesRef SingleToBytesRef(float v)
         {
-            return IntAssociationFacetField.Int32ToBytesRef(Number.SingleToInt32Bits(v));
+            return Int32AssociationFacetField.Int32ToBytesRef(Number.SingleToInt32Bits(v));
         }
 
         /// <summary>
@@ -58,7 +60,7 @@ namespace Lucene.Net.Facet.Taxonomy
         /// </summary>
         public static float BytesRefToSingle(BytesRef b)
         {
-            return Number.Int32BitsToSingle(IntAssociationFacetField.BytesRefToInt32(b));
+            return Number.Int32BitsToSingle(Int32AssociationFacetField.BytesRefToInt32(b));
         }
 
         public override string ToString()

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c3485316/src/Lucene.Net.Facet/Taxonomy/FloatTaxonomyFacets.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/FloatTaxonomyFacets.cs b/src/Lucene.Net.Facet/Taxonomy/FloatTaxonomyFacets.cs
index 608300b..3549c6f 100644
--- a/src/Lucene.Net.Facet/Taxonomy/FloatTaxonomyFacets.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/FloatTaxonomyFacets.cs
@@ -25,9 +25,11 @@ namespace Lucene.Net.Facet.Taxonomy
 
     /// <summary>
     /// Base class for all taxonomy-based facets that aggregate
-    /// to a per-ords <see cref="T:float[]"/>. 
+    /// to a per-ords <see cref="T:float[]"/>.
+    /// <para/>
+    /// NOTE: This was FloatTaxonomyFacets in Lucene
     /// </summary>
-    public abstract class FloatTaxonomyFacets : TaxonomyFacets
+    public abstract class SingleTaxonomyFacets : TaxonomyFacets
     {
         /// <summary>
         /// Per-ordinal value. </summary>
@@ -36,7 +38,7 @@ namespace Lucene.Net.Facet.Taxonomy
         /// <summary>
         /// Sole constructor.
         /// </summary>
-        protected FloatTaxonomyFacets(string indexFieldName, TaxonomyReader taxoReader, FacetsConfig config)
+        protected SingleTaxonomyFacets(string indexFieldName, TaxonomyReader taxoReader, FacetsConfig config)
             : base(indexFieldName, taxoReader, config)
         {
             m_values = new float[taxoReader.Count];
@@ -114,14 +116,14 @@ namespace Lucene.Net.Facet.Taxonomy
                 return null;
             }
 
-            TopOrdAndFloatQueue q = new TopOrdAndFloatQueue(Math.Min(m_taxoReader.Count, topN));
+            TopOrdAndSingleQueue q = new TopOrdAndSingleQueue(Math.Min(m_taxoReader.Count, topN));
             float bottomValue = 0;
 
             int ord = m_children[dimOrd];
             float sumValues = 0;
             int childCount = 0;
 
-            TopOrdAndFloatQueue.OrdAndValue reuse = null;
+            TopOrdAndSingleQueue.OrdAndValue reuse = null;
             while (ord != TaxonomyReader.INVALID_ORDINAL)
             {
                 if (m_values[ord] > 0)
@@ -132,7 +134,7 @@ namespace Lucene.Net.Facet.Taxonomy
                     {
                         if (reuse == null)
                         {
-                            reuse = new TopOrdAndFloatQueue.OrdAndValue();
+                            reuse = new TopOrdAndSingleQueue.OrdAndValue();
                         }
                         reuse.Ord = ord;
                         reuse.Value = m_values[ord];
@@ -172,7 +174,7 @@ namespace Lucene.Net.Facet.Taxonomy
             LabelAndValue[] labelValues = new LabelAndValue[q.Count];
             for (int i = labelValues.Length - 1; i >= 0; i--)
             {
-                TopOrdAndFloatQueue.OrdAndValue ordAndValue = q.Pop();
+                TopOrdAndSingleQueue.OrdAndValue ordAndValue = q.Pop();
                 FacetLabel child = m_taxoReader.GetPath(ordAndValue.Ord);
                 labelValues[i] = new LabelAndValue(child.Components[cp.Length], ordAndValue.Value);
             }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c3485316/src/Lucene.Net.Facet/Taxonomy/IntAssociationFacetField.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/IntAssociationFacetField.cs b/src/Lucene.Net.Facet/Taxonomy/IntAssociationFacetField.cs
index 3385cdb..c657976 100644
--- a/src/Lucene.Net.Facet/Taxonomy/IntAssociationFacetField.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/IntAssociationFacetField.cs
@@ -24,18 +24,20 @@ namespace Lucene.Net.Facet.Taxonomy
 
     /// <summary>
     /// Add an instance of this to your <see cref="Document"/> to add
-    /// a facet label associated with an int.  Use <see cref="TaxonomyFacetSumIntAssociations"/>
+    /// a facet label associated with an <see cref="int"/>.  Use <see cref="TaxonomyFacetSumInt32Associations"/>
     /// to aggregate int values per facet label at search time.
+    /// <para/>
+    /// NOTE: This was IntAssociationFacetField in Lucene
     /// 
     ///  @lucene.experimental 
     /// </summary>
-    public class IntAssociationFacetField : AssociationFacetField
+    public class Int32AssociationFacetField : AssociationFacetField
     {
         /// <summary>
         /// Creates this from <paramref name="dim"/> and <paramref name="path"/> and an
         /// int association 
         /// </summary>
-        public IntAssociationFacetField(int assoc, string dim, params string[] path)
+        public Int32AssociationFacetField(int assoc, string dim, params string[] path)
             : base(Int32ToBytesRef(assoc), dim, path)
         {
         }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c3485316/src/Lucene.Net.Facet/Taxonomy/IntTaxonomyFacets.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/IntTaxonomyFacets.cs b/src/Lucene.Net.Facet/Taxonomy/IntTaxonomyFacets.cs
index 2b223e6..f1ac66f 100644
--- a/src/Lucene.Net.Facet/Taxonomy/IntTaxonomyFacets.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/IntTaxonomyFacets.cs
@@ -24,10 +24,11 @@ namespace Lucene.Net.Facet.Taxonomy
 
     /// <summary>
     /// Base class for all taxonomy-based facets that aggregate
-    /// to a per-ords <see cref="T:int[]"/>. 
+    /// to a per-ords <see cref="T:int[]"/>.
+    /// <para/>
+    /// NOTE: This was IntTaxonomyFacets in Lucene
     /// </summary>
-
-    public abstract class IntTaxonomyFacets : TaxonomyFacets
+    public abstract class Int32TaxonomyFacets : TaxonomyFacets
     {
         /// <summary>
         /// Per-ordinal value. </summary>
@@ -36,7 +37,7 @@ namespace Lucene.Net.Facet.Taxonomy
         /// <summary>
         /// Sole constructor.
         /// </summary>
-        protected IntTaxonomyFacets(string indexFieldName, TaxonomyReader taxoReader, FacetsConfig config)
+        protected Int32TaxonomyFacets(string indexFieldName, TaxonomyReader taxoReader, FacetsConfig config)
             : base(indexFieldName, taxoReader, config)
         {
             m_values = new int[taxoReader.Count];
@@ -118,7 +119,7 @@ namespace Lucene.Net.Facet.Taxonomy
                 return null;
             }
 
-            TopOrdAndIntQueue q = new TopOrdAndIntQueue(Math.Min(m_taxoReader.Count, topN));
+            TopOrdAndInt32Queue q = new TopOrdAndInt32Queue(Math.Min(m_taxoReader.Count, topN));
 
             int bottomValue = 0;
 
@@ -126,7 +127,7 @@ namespace Lucene.Net.Facet.Taxonomy
             int totValue = 0;
             int childCount = 0;
 
-            TopOrdAndIntQueue.OrdAndValue reuse = null;
+            TopOrdAndInt32Queue.OrdAndValue reuse = null;
             while (ord != TaxonomyReader.INVALID_ORDINAL)
             {
                 if (m_values[ord] > 0)
@@ -137,7 +138,7 @@ namespace Lucene.Net.Facet.Taxonomy
                     {
                         if (reuse == null)
                         {
-                            reuse = new TopOrdAndIntQueue.OrdAndValue();
+                            reuse = new TopOrdAndInt32Queue.OrdAndValue();
                         }
                         reuse.Ord = ord;
                         reuse.Value = m_values[ord];
@@ -177,7 +178,7 @@ namespace Lucene.Net.Facet.Taxonomy
             LabelAndValue[] labelValues = new LabelAndValue[q.Count];
             for (int i = labelValues.Length - 1; i >= 0; i--)
             {
-                TopOrdAndIntQueue.OrdAndValue ordAndValue = q.Pop();
+                TopOrdAndInt32Queue.OrdAndValue ordAndValue = q.Pop();
                 FacetLabel child = m_taxoReader.GetPath(ordAndValue.Ord);
                 labelValues[i] = new LabelAndValue(child.Components[cp.Length], ordAndValue.Value);
             }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c3485316/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetCounts.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetCounts.cs b/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetCounts.cs
index 181cc45..0014366 100644
--- a/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetCounts.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetCounts.cs
@@ -30,7 +30,7 @@ namespace Lucene.Net.Facet.Taxonomy
     /// 
     /// @lucene.experimental 
     /// </summary>
-    public class TaxonomyFacetCounts : IntTaxonomyFacets
+    public class TaxonomyFacetCounts : Int32TaxonomyFacets
     {
         private readonly OrdinalsReader ordinalsReader;
 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c3485316/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetSumFloatAssociations.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetSumFloatAssociations.cs b/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetSumFloatAssociations.cs
index b36474e..2b907cb 100644
--- a/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetSumFloatAssociations.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetSumFloatAssociations.cs
@@ -26,28 +26,30 @@ namespace Lucene.Net.Facet.Taxonomy
     using MatchingDocs = FacetsCollector.MatchingDocs;
 
     /// <summary>
-    /// Aggregates sum of int values previously indexed with
-    /// <see cref="FloatAssociationFacetField"/>, assuming the default
+    /// Aggregates sum of <see cref="float"/> values previously indexed with
+    /// <see cref="SingleAssociationFacetField"/>, assuming the default
     /// encoding.
+    /// <para/>
+    /// NOTE: This was TaxonomyFacetSumFloatAssociations in Lucene
     /// 
     ///  @lucene.experimental 
     /// </summary>
-    public class TaxonomyFacetSumFloatAssociations : FloatTaxonomyFacets
+    public class TaxonomyFacetSumSingleAssociations : SingleTaxonomyFacets
     {
         /// <summary>
-        /// Create <see cref="TaxonomyFacetSumFloatAssociations"/> against
+        /// Create <see cref="TaxonomyFacetSumSingleAssociations"/> against
         /// the default index field. 
         /// </summary>
-        public TaxonomyFacetSumFloatAssociations(TaxonomyReader taxoReader, FacetsConfig config, FacetsCollector fc)
+        public TaxonomyFacetSumSingleAssociations(TaxonomyReader taxoReader, FacetsConfig config, FacetsCollector fc)
             : this(FacetsConfig.DEFAULT_INDEX_FIELD_NAME, taxoReader, config, fc)
         {
         }
 
         /// <summary>
-        /// Create <see cref="TaxonomyFacetSumFloatAssociations"/> against
+        /// Create <see cref="TaxonomyFacetSumSingleAssociations"/> against
         /// the specified index field. 
         /// </summary>
-        public TaxonomyFacetSumFloatAssociations(string indexFieldName, TaxonomyReader taxoReader, FacetsConfig config, FacetsCollector fc)
+        public TaxonomyFacetSumSingleAssociations(string indexFieldName, TaxonomyReader taxoReader, FacetsConfig config, FacetsCollector fc)
             : base(indexFieldName, taxoReader, config)
         {
             SumValues(fc.GetMatchingDocs());

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c3485316/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetSumIntAssociations.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetSumIntAssociations.cs b/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetSumIntAssociations.cs
index fc45bdb..7702b25 100644
--- a/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetSumIntAssociations.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetSumIntAssociations.cs
@@ -25,28 +25,30 @@ namespace Lucene.Net.Facet.Taxonomy
     using MatchingDocs = FacetsCollector.MatchingDocs;
 
     /// <summary>
-    /// Aggregates sum of int values previously indexed with
-    /// <see cref="IntAssociationFacetField"/>, assuming the default
+    /// Aggregates sum of <see cref="int"/> values previously indexed with
+    /// <see cref="Int32AssociationFacetField"/>, assuming the default
     /// encoding.
+    /// <para/>
+    /// NOTE: This was TaxonomyFacetSumIntAssociations in Lucene
     /// 
     ///  @lucene.experimental 
     /// </summary>
-    public class TaxonomyFacetSumIntAssociations : IntTaxonomyFacets
+    public class TaxonomyFacetSumInt32Associations : Int32TaxonomyFacets
     {
         /// <summary>
-        /// Create <see cref="TaxonomyFacetSumIntAssociations"/> against
+        /// Create <see cref="TaxonomyFacetSumInt32Associations"/> against
         /// the default index field. 
         /// </summary>
-        public TaxonomyFacetSumIntAssociations(TaxonomyReader taxoReader, FacetsConfig config, FacetsCollector fc)
+        public TaxonomyFacetSumInt32Associations(TaxonomyReader taxoReader, FacetsConfig config, FacetsCollector fc)
             : this(FacetsConfig.DEFAULT_INDEX_FIELD_NAME, taxoReader, config, fc)
         {
         }
 
         /// <summary>
-        /// Create <see cref="TaxonomyFacetSumIntAssociations"/> against
+        /// Create <see cref="TaxonomyFacetSumInt32Associations"/> against
         /// the specified index field. 
         /// </summary>
-        public TaxonomyFacetSumIntAssociations(string indexFieldName, TaxonomyReader taxoReader, FacetsConfig config, FacetsCollector fc)
+        public TaxonomyFacetSumInt32Associations(string indexFieldName, TaxonomyReader taxoReader, FacetsConfig config, FacetsCollector fc)
             : base(indexFieldName, taxoReader, config)
         {
             SumValues(fc.GetMatchingDocs());

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c3485316/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetSumValueSource.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetSumValueSource.cs b/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetSumValueSource.cs
index b2c6473..2004ad2 100644
--- a/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetSumValueSource.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetSumValueSource.cs
@@ -39,7 +39,7 @@ namespace Lucene.Net.Facet.Taxonomy
     /// 
     ///  @lucene.experimental 
     /// </summary>
-    public class TaxonomyFacetSumValueSource : FloatTaxonomyFacets
+    public class TaxonomyFacetSumValueSource : SingleTaxonomyFacets
     {
         private readonly OrdinalsReader ordinalsReader;
 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c3485316/src/Lucene.Net.Facet/Taxonomy/WriterCache/LruTaxonomyWriterCache.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/WriterCache/LruTaxonomyWriterCache.cs b/src/Lucene.Net.Facet/Taxonomy/WriterCache/LruTaxonomyWriterCache.cs
index d7d5676..af8324b 100644
--- a/src/Lucene.Net.Facet/Taxonomy/WriterCache/LruTaxonomyWriterCache.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/WriterCache/LruTaxonomyWriterCache.cs
@@ -44,7 +44,7 @@
             LRU_STRING
         }
 
-        private NameIntCacheLRU cache;
+        private NameInt32CacheLRU cache;
 
         /// <summary>
         /// Creates this with <see cref="LRUType.LRU_HASHED"/> method.
@@ -73,11 +73,11 @@
             // mapped to the same ordinal...
             if (lruType == LRUType.LRU_HASHED)
             {
-                this.cache = new NameHashIntCacheLRU(cacheSize);
+                this.cache = new NameHashInt32CacheLRU(cacheSize);
             }
             else
             {
-                this.cache = new NameIntCacheLRU(cacheSize);
+                this.cache = new NameInt32CacheLRU(cacheSize);
             }
         }
 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c3485316/src/Lucene.Net.Facet/Taxonomy/WriterCache/NameHashIntCacheLRU.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/WriterCache/NameHashIntCacheLRU.cs b/src/Lucene.Net.Facet/Taxonomy/WriterCache/NameHashIntCacheLRU.cs
index 7e2c95e..0bc40d4 100644
--- a/src/Lucene.Net.Facet/Taxonomy/WriterCache/NameHashIntCacheLRU.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/WriterCache/NameHashIntCacheLRU.cs
@@ -22,13 +22,15 @@
     /// Used to cache Ordinals of category paths.
     /// It uses as key, hash of the path instead of the path.
     /// This way the cache takes less RAM, but correctness depends on
-    /// assuming no collisions. 
+    /// assuming no collisions.
+    /// <para/>
+    /// NOTE: this was NameHashIntCacheLRU in Lucene
     /// 
     /// @lucene.experimental
     /// </summary>
-    public class NameHashIntCacheLRU : NameIntCacheLRU
+    public class NameHashInt32CacheLRU : NameInt32CacheLRU
     {
-        internal NameHashIntCacheLRU(int maxCacheSize)
+        internal NameHashInt32CacheLRU(int maxCacheSize)
             : base(maxCacheSize)
         {
         }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c3485316/src/Lucene.Net.Facet/Taxonomy/WriterCache/NameIntCacheLRU.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/WriterCache/NameIntCacheLRU.cs b/src/Lucene.Net.Facet/Taxonomy/WriterCache/NameIntCacheLRU.cs
index 6b849f8..efe30c7 100644
--- a/src/Lucene.Net.Facet/Taxonomy/WriterCache/NameIntCacheLRU.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/WriterCache/NameIntCacheLRU.cs
@@ -24,6 +24,8 @@ namespace Lucene.Net.Facet.Taxonomy.WriterCache
     /// <summary>
     /// An an LRU cache of mapping from name to int.
     /// Used to cache Ordinals of category paths.
+    /// <para/>
+    /// NOTE: This was NameIntCacheLRU in Lucene
     /// 
     /// @lucene.experimental
     /// </summary>
@@ -31,14 +33,14 @@ namespace Lucene.Net.Facet.Taxonomy.WriterCache
     /// Note: Nothing in this class is synchronized. The caller is assumed to be
     /// synchronized so that no two methods of this class are called concurrently.
     /// </remarks>
-    public class NameIntCacheLRU
+    public class NameInt32CacheLRU
     {
         private IDictionary<object, int> cache;
         internal long nMisses = 0; // for debug
         internal long nHits = 0; // for debug
         private int capacity;
 
-        internal NameIntCacheLRU(int capacity)
+        internal NameInt32CacheLRU(int capacity)
         {
             this.capacity = capacity;
             CreateCache(capacity);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c3485316/src/Lucene.Net.Facet/TopOrdAndFloatQueue.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/TopOrdAndFloatQueue.cs b/src/Lucene.Net.Facet/TopOrdAndFloatQueue.cs
index ffa52e7..62fb389 100644
--- a/src/Lucene.Net.Facet/TopOrdAndFloatQueue.cs
+++ b/src/Lucene.Net.Facet/TopOrdAndFloatQueue.cs
@@ -20,10 +20,12 @@ namespace Lucene.Net.Facet
 	 */
 
     /// <summary>
-    /// Keeps highest results, first by largest float value,
-    /// then tie break by smallest ord. 
+    /// Keeps highest results, first by largest <see cref="float"/> value,
+    /// then tie break by smallest ord.
+    /// <para/>
+    /// NOTE: This was TopOrdAndFloatQueue in Lucene
     /// </summary>
-    public class TopOrdAndFloatQueue : PriorityQueue<TopOrdAndFloatQueue.OrdAndValue>
+    public class TopOrdAndSingleQueue : PriorityQueue<TopOrdAndSingleQueue.OrdAndValue>
     {
         /// <summary>
         /// Holds a single entry.
@@ -49,7 +51,7 @@ namespace Lucene.Net.Facet
         /// <summary>
         /// Sole constructor.
         /// </summary>
-        public TopOrdAndFloatQueue(int topN) : base(topN, false)
+        public TopOrdAndSingleQueue(int topN) : base(topN, false)
         {
         }
 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c3485316/src/Lucene.Net.Facet/TopOrdAndIntQueue.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/TopOrdAndIntQueue.cs b/src/Lucene.Net.Facet/TopOrdAndIntQueue.cs
index fb44dc9..cb78b69 100644
--- a/src/Lucene.Net.Facet/TopOrdAndIntQueue.cs
+++ b/src/Lucene.Net.Facet/TopOrdAndIntQueue.cs
@@ -20,10 +20,12 @@ namespace Lucene.Net.Facet
      */
 
     /// <summary>
-    /// Keeps highest results, first by largest int value,
-    /// then tie break by smallest ord. 
+    /// Keeps highest results, first by largest <see cref="int"/> value,
+    /// then tie break by smallest ord.
+    /// <para/>
+    /// NOTE: This was TopOrdAndIntQueue in Lucene
     /// </summary>
-    public class TopOrdAndIntQueue : PriorityQueue<TopOrdAndIntQueue.OrdAndValue>
+    public class TopOrdAndInt32Queue : PriorityQueue<TopOrdAndInt32Queue.OrdAndValue>
     {
         /// <summary>
         /// Holds a single entry.
@@ -49,7 +51,7 @@ namespace Lucene.Net.Facet
         /// <summary>
         /// Sole constructor.
         /// </summary>
-        public TopOrdAndIntQueue(int topN)
+        public TopOrdAndInt32Queue(int topN)
             : base(topN, false)
         {
         }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c3485316/src/Lucene.Net.Tests.Facet/Range/TestRangeFacetCounts.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Facet/Range/TestRangeFacetCounts.cs b/src/Lucene.Net.Tests.Facet/Range/TestRangeFacetCounts.cs
index d128c36..b41e3df 100644
--- a/src/Lucene.Net.Tests.Facet/Range/TestRangeFacetCounts.cs
+++ b/src/Lucene.Net.Tests.Facet/Range/TestRangeFacetCounts.cs
@@ -94,7 +94,7 @@ namespace Lucene.Net.Facet.Range
             IndexSearcher s = NewSearcher(r);
             s.Search(new MatchAllDocsQuery(), fc);
 
-            Facets facets = new LongRangeFacetCounts("field", fc, new LongRange("less than 10", 0L, true, 10L, false), new LongRange("less than or equal to 10", 0L, true, 10L, true), new LongRange("over 90", 90L, false, 100L, false), new LongRange("90 or above", 90L, true, 100L, false), new LongRange("over 1000", 1000L, false, long.MaxValue, true));
+            Facets facets = new Int64RangeFacetCounts("field", fc, new Int64Range("less than 10", 0L, true, 10L, false), new Int64Range("less than or equal to 10", 0L, true, 10L, true), new Int64Range("over 90", 90L, false, 100L, false), new Int64Range("90 or above", 90L, true, 100L, false), new Int64Range("over 1000", 1000L, false, long.MaxValue, true));
 
             FacetResult result = facets.GetTopChildren(10, "field");
 
@@ -109,7 +109,7 @@ namespace Lucene.Net.Facet.Range
         {
             try
             {
-                new LongRange("useless", 7, true, 6, true);
+                new Int64Range("useless", 7, true, 6, true);
                 Fail("did not hit expected exception");
             }
             catch (System.ArgumentException)
@@ -118,7 +118,7 @@ namespace Lucene.Net.Facet.Range
             }
             try
             {
-                new LongRange("useless", 7, true, 7, false);
+                new Int64Range("useless", 7, true, 7, false);
                 Fail("did not hit expected exception");
             }
             catch (System.ArgumentException)
@@ -168,7 +168,7 @@ namespace Lucene.Net.Facet.Range
             IndexSearcher s = NewSearcher(r);
             s.Search(new MatchAllDocsQuery(), fc);
 
-            Facets facets = new LongRangeFacetCounts("field", fc, new LongRange("min", long.MinValue, true, long.MinValue, true), new LongRange("max", long.MaxValue, true, long.MaxValue, true), new LongRange("all0", long.MinValue, true, long.MaxValue, true), new LongRange("all1", long.MinValue, false, long.MaxValue, true), new LongRange("all2", long.MinValue, true, long.MaxValue, false), new LongRange("all3", long.MinValue, false, long.MaxValue, false));
+            Facets facets = new Int64RangeFacetCounts("field", fc, new Int64Range("min", long.MinValue, true, long.MinValue, true), new Int64Range("max", long.MaxValue, true, long.MaxValue, true), new Int64Range("all0", long.MinValue, true, long.MaxValue, true), new Int64Range("all1", long.MinValue, false, long.MaxValue, true), new Int64Range("all2", long.MinValue, true, long.MaxValue, false), new Int64Range("all3", long.MinValue, false, long.MaxValue, false));
 
             FacetResult result = facets.GetTopChildren(10, "field");
             Assert.AreEqual("dim=field path=[] value=3 childCount=6\n  min (1)\n  max (1)\n  all0 (3)\n  all1 (2)\n  all2 (2)\n  all3 (1)\n", result.ToString());
@@ -200,7 +200,7 @@ namespace Lucene.Net.Facet.Range
             IndexSearcher s = NewSearcher(r);
             s.Search(new MatchAllDocsQuery(), fc);
 
-            Facets facets = new LongRangeFacetCounts("field", fc, new LongRange("0-10", 0L, true, 10L, true), new LongRange("10-20", 10L, true, 20L, true), new LongRange("20-30", 20L, true, 30L, true), new LongRange("30-40", 30L, true, 40L, true));
+            Facets facets = new Int64RangeFacetCounts("field", fc, new Int64Range("0-10", 0L, true, 10L, true), new Int64Range("10-20", 10L, true, 20L, true), new Int64Range("20-30", 20L, true, 30L, true), new Int64Range("30-40", 30L, true, 40L, true));
 
             FacetResult result = facets.GetTopChildren(10, "field");
             Assert.AreEqual("dim=field path=[] value=41 childCount=4\n  0-10 (11)\n  10-20 (11)\n  20-30 (11)\n  30-40 (11)\n", result.ToString());
@@ -314,7 +314,7 @@ namespace Lucene.Net.Facet.Range
                 }
 
                 IDictionary<string, Facets> byDim = new Dictionary<string, Facets>();
-                byDim["field"] = new LongRangeFacetCounts("field", fieldFC, new LongRange("less than 10", 0L, true, 10L, false), new LongRange("less than or equal to 10", 0L, true, 10L, true), new LongRange("over 90", 90L, false, 100L, false), new LongRange("90 or above", 90L, true, 100L, false), new LongRange("over 1000", 1000L, false, long.MaxValue, false));
+                byDim["field"] = new Int64RangeFacetCounts("field", fieldFC, new Int64Range("less than 10", 0L, true, 10L, false), new Int64Range("less than or equal to 10", 0L, true, 10L, true), new Int64Range("over 90", 90L, false, 100L, false), new Int64Range("90 or above", 90L, true, 100L, false), new Int64Range("over 1000", 1000L, false, long.MaxValue, false));
                 byDim["dim"] = outerInstance.GetTaxonomyFacetCounts(m_taxoReader, m_config, dimFC);
                 return new MultiFacets(byDim, null);
             }
@@ -418,7 +418,7 @@ namespace Lucene.Net.Facet.Range
                     Console.WriteLine("TEST: iter=" + iter);
                 }
                 int numRange = TestUtil.NextInt(Random(), 1, 100);
-                LongRange[] ranges = new LongRange[numRange];
+                Int64Range[] ranges = new Int64Range[numRange];
                 int[] expectedCounts = new int[numRange];
                 long minAcceptedValue = long.MaxValue;
                 long maxAcceptedValue = long.MinValue;
@@ -428,7 +428,7 @@ namespace Lucene.Net.Facet.Range
                     if (rangeID > 0 && Random().Next(10) == 7)
                     {
                         // Use an existing boundary:
-                        LongRange prevRange = ranges[Random().Next(rangeID)];
+                        Int64Range prevRange = ranges[Random().Next(rangeID)];
                         if (Random().NextBoolean())
                         {
                             min = prevRange.Min;
@@ -446,7 +446,7 @@ namespace Lucene.Net.Facet.Range
                     if (rangeID > 0 && Random().Next(10) == 7)
                     {
                         // Use an existing boundary:
-                        LongRange prevRange = ranges[Random().Next(rangeID)];
+                        Int64Range prevRange = ranges[Random().Next(rangeID)];
                         if (Random().NextBoolean())
                         {
                             max = prevRange.Min;
@@ -479,7 +479,7 @@ namespace Lucene.Net.Facet.Range
                         minIncl = Random().NextBoolean();
                         maxIncl = Random().NextBoolean();
                     }
-                    ranges[rangeID] = new LongRange("r" + rangeID, min, minIncl, max, maxIncl);
+                    ranges[rangeID] = new Int64Range("r" + rangeID, min, minIncl, max, maxIncl);
                     if (VERBOSE)
                     {
                         Console.WriteLine("  range " + rangeID + ": " + ranges[rangeID]);
@@ -534,7 +534,7 @@ namespace Lucene.Net.Facet.Range
                     fastMatchFilter = null;
                 }
                 ValueSource vs = new LongFieldSource("field");
-                Facets facets = new LongRangeFacetCounts("field", vs, sfc, fastMatchFilter, ranges);
+                Facets facets = new Int64RangeFacetCounts("field", vs, sfc, fastMatchFilter, ranges);
                 FacetResult result = facets.GetTopChildren(10, "field");
                 Assert.AreEqual(numRange, result.LabelValues.Length);
                 for (int rangeID = 0; rangeID < numRange; rangeID++)
@@ -547,7 +547,7 @@ namespace Lucene.Net.Facet.Range
                     Assert.AreEqual("r" + rangeID, subNode.Label);
                     Assert.AreEqual(expectedCounts[rangeID], (int)subNode.Value);
 
-                    LongRange range = ranges[rangeID];
+                    Int64Range range = ranges[rangeID];
 
                     // Test drill-down:
                     DrillDownQuery ddq = new DrillDownQuery(config);
@@ -993,7 +993,7 @@ namespace Lucene.Net.Facet.Range
 
             IndexSearcher s = NewSearcher(r);
             s.Search(new MatchAllDocsQuery(), fc);
-            Facets facets = new LongRangeFacetCounts("field", fc, new LongRange("less than 10", 0L, true, 10L, false), new LongRange("less than or equal to 10", 0L, true, 10L, true), new LongRange("over 90", 90L, false, 100L, false), new LongRange("90 or above", 90L, true, 100L, false), new LongRange("over 1000", 1000L, false, long.MaxValue, false));
+            Facets facets = new Int64RangeFacetCounts("field", fc, new Int64Range("less than 10", 0L, true, 10L, false), new Int64Range("less than or equal to 10", 0L, true, 10L, true), new Int64Range("over 90", 90L, false, 100L, false), new Int64Range("90 or above", 90L, true, 100L, false), new Int64Range("over 1000", 1000L, false, long.MaxValue, false));
 
             Assert.AreEqual("dim=field path=[] value=16 childCount=5\n  less than 10 (8)\n  less than or equal to 10 (8)\n  over 90 (8)\n  90 or above (8)\n  over 1000 (0)\n", facets.GetTopChildren(10, "field").ToString());
 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c3485316/src/Lucene.Net.Tests.Facet/Taxonomy/TestFacetLabel.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Facet/Taxonomy/TestFacetLabel.cs b/src/Lucene.Net.Tests.Facet/Taxonomy/TestFacetLabel.cs
index 2b87829..a6ca76e 100644
--- a/src/Lucene.Net.Tests.Facet/Taxonomy/TestFacetLabel.cs
+++ b/src/Lucene.Net.Tests.Facet/Taxonomy/TestFacetLabel.cs
@@ -203,7 +203,7 @@ namespace Lucene.Net.Facet.Taxonomy
                 }
                 try
                 {
-                    new IntAssociationFacetField(17, "dim", components);
+                    new Int32AssociationFacetField(17, "dim", components);
                     Fail("empty or null components should not be allowed: " + Arrays.ToString(components));
                 }
                 catch (System.ArgumentException)
@@ -212,7 +212,7 @@ namespace Lucene.Net.Facet.Taxonomy
                 }
                 try
                 {
-                    new FloatAssociationFacetField(17.0f, "dim", components);
+                    new SingleAssociationFacetField(17.0f, "dim", components);
                     Fail("empty or null components should not be allowed: " + Arrays.ToString(components));
                 }
                 catch (System.ArgumentException)
@@ -240,7 +240,7 @@ namespace Lucene.Net.Facet.Taxonomy
             }
             try
             {
-                new IntAssociationFacetField(17, null, new string[] { "abc" });
+                new Int32AssociationFacetField(17, null, new string[] { "abc" });
                 Fail("empty or null components should not be allowed");
             }
             catch (System.ArgumentException)
@@ -249,7 +249,7 @@ namespace Lucene.Net.Facet.Taxonomy
             }
             try
             {
-                new IntAssociationFacetField(17, "", new string[] { "abc" });
+                new Int32AssociationFacetField(17, "", new string[] { "abc" });
                 Fail("empty or null components should not be allowed");
             }
             catch (System.ArgumentException)
@@ -258,7 +258,7 @@ namespace Lucene.Net.Facet.Taxonomy
             }
             try
             {
-                new FloatAssociationFacetField(17.0f, null, new string[] { "abc" });
+                new SingleAssociationFacetField(17.0f, null, new string[] { "abc" });
                 Fail("empty or null components should not be allowed");
             }
             catch (System.ArgumentException)
@@ -267,7 +267,7 @@ namespace Lucene.Net.Facet.Taxonomy
             }
             try
             {
-                new FloatAssociationFacetField(17.0f, "", new string[] { "abc" });
+                new SingleAssociationFacetField(17.0f, "", new string[] { "abc" });
                 Fail("empty or null components should not be allowed");
             }
             catch (System.ArgumentException)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c3485316/src/Lucene.Net.Tests.Facet/Taxonomy/TestTaxonomyFacetAssociations.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Facet/Taxonomy/TestTaxonomyFacetAssociations.cs b/src/Lucene.Net.Tests.Facet/Taxonomy/TestTaxonomyFacetAssociations.cs
index fc38863..c7e4c32 100644
--- a/src/Lucene.Net.Tests.Facet/Taxonomy/TestTaxonomyFacetAssociations.cs
+++ b/src/Lucene.Net.Tests.Facet/Taxonomy/TestTaxonomyFacetAssociations.cs
@@ -75,12 +75,12 @@ namespace Lucene.Net.Facet.Taxonomy
                 // aggregators to go into an infinite loop
                 if (i % 11 != 0)
                 {
-                    doc.Add(new IntAssociationFacetField(2, "int", "a"));
-                    doc.Add(new FloatAssociationFacetField(0.5f, "float", "a"));
+                    doc.Add(new Int32AssociationFacetField(2, "int", "a"));
+                    doc.Add(new SingleAssociationFacetField(0.5f, "float", "a"));
                     if (i % 2 == 0) // 50
                     {
-                        doc.Add(new IntAssociationFacetField(3, "int", "b"));
-                        doc.Add(new FloatAssociationFacetField(0.2f, "float", "b"));
+                        doc.Add(new Int32AssociationFacetField(3, "int", "b"));
+                        doc.Add(new SingleAssociationFacetField(0.2f, "float", "b"));
                     }
                 }
                 writer.AddDocument(config.Build(taxoWriter, doc));
@@ -114,7 +114,7 @@ namespace Lucene.Net.Facet.Taxonomy
             IndexSearcher searcher = NewSearcher(reader);
             searcher.Search(new MatchAllDocsQuery(), fc);
 
-            Facets facets = new TaxonomyFacetSumIntAssociations("$facets.int", taxoReader, config, fc);
+            Facets facets = new TaxonomyFacetSumInt32Associations("$facets.int", taxoReader, config, fc);
             Assert.AreEqual("dim=int path=[] value=-1 childCount=2\n  a (200)\n  b (150)\n", facets.GetTopChildren(10, "int").ToString());
             Assert.AreEqual(200, (int)facets.GetSpecificValue("int", "a"), "Wrong count for category 'a'!");
             Assert.AreEqual(150, (int)facets.GetSpecificValue("int", "b"), "Wrong count for category 'b'!");
@@ -128,7 +128,7 @@ namespace Lucene.Net.Facet.Taxonomy
             IndexSearcher searcher = NewSearcher(reader);
             searcher.Search(new MatchAllDocsQuery(), fc);
 
-            Facets facets = new TaxonomyFacetSumFloatAssociations("$facets.float", taxoReader, config, fc);
+            Facets facets = new TaxonomyFacetSumSingleAssociations("$facets.float", taxoReader, config, fc);
             Assert.AreEqual("dim=float path=[] value=-1.0 childCount=2\n  a (50.0)\n  b (9.999995)\n", facets.GetTopChildren(10, "float").ToString());
             Assert.AreEqual(50f, (float)facets.GetSpecificValue("float", "a"), 0.00001, "Wrong count for category 'a'!");
             Assert.AreEqual(10f, (float)facets.GetSpecificValue("float", "b"), 0.00001, "Wrong count for category 'b'!");
@@ -146,11 +146,11 @@ namespace Lucene.Net.Facet.Taxonomy
             IndexSearcher searcher = NewSearcher(reader);
             searcher.Search(new MatchAllDocsQuery(), fc);
 
-            Facets facets = new TaxonomyFacetSumFloatAssociations("$facets.float", taxoReader, config, fc);
+            Facets facets = new TaxonomyFacetSumSingleAssociations("$facets.float", taxoReader, config, fc);
             Assert.AreEqual(50f, (float)facets.GetSpecificValue("float", "a"), 0.00001, "Wrong count for category 'a'!");
             Assert.AreEqual(10f, (float)facets.GetSpecificValue("float", "b"), 0.00001, "Wrong count for category 'b'!");
 
-            facets = new TaxonomyFacetSumIntAssociations("$facets.int", taxoReader, config, fc);
+            facets = new TaxonomyFacetSumInt32Associations("$facets.int", taxoReader, config, fc);
             Assert.AreEqual(200, (int)facets.GetSpecificValue("int", "a"), "Wrong count for category 'a'!");
             Assert.AreEqual(150, (int)facets.GetSpecificValue("int", "b"), "Wrong count for category 'b'!");
         }
@@ -163,7 +163,7 @@ namespace Lucene.Net.Facet.Taxonomy
 
             IndexSearcher searcher = NewSearcher(reader);
             searcher.Search(new MatchAllDocsQuery(), fc);
-            Facets facets = new TaxonomyFacetSumFloatAssociations(taxoReader, config, fc);
+            Facets facets = new TaxonomyFacetSumSingleAssociations(taxoReader, config, fc);
             try
             {
                 facets.GetSpecificValue("float");
@@ -196,8 +196,8 @@ namespace Lucene.Net.Facet.Taxonomy
             RandomIndexWriter writer = new RandomIndexWriter(Random(), dir, Similarity, TimeZone);
 
             Document doc = new Document();
-            doc.Add(new IntAssociationFacetField(14, "a", "x"));
-            doc.Add(new FloatAssociationFacetField(55.0f, "b", "y"));
+            doc.Add(new Int32AssociationFacetField(14, "a", "x"));
+            doc.Add(new SingleAssociationFacetField(55.0f, "b", "y"));
             try
             {
                 writer.AddDocument(config.Build(taxoWriter, doc));
@@ -222,7 +222,7 @@ namespace Lucene.Net.Facet.Taxonomy
             RandomIndexWriter writer = new RandomIndexWriter(Random(), dir, Similarity, TimeZone);
 
             Document doc = new Document();
-            doc.Add(new IntAssociationFacetField(14, "a", "x"));
+            doc.Add(new Int32AssociationFacetField(14, "a", "x"));
             try
             {
                 writer.AddDocument(config.Build(taxoWriter, doc));
@@ -247,7 +247,7 @@ namespace Lucene.Net.Facet.Taxonomy
             RandomIndexWriter writer = new RandomIndexWriter(Random(), dir, Similarity, TimeZone);
 
             Document doc = new Document();
-            doc.Add(new IntAssociationFacetField(14, "a", "x"));
+            doc.Add(new Int32AssociationFacetField(14, "a", "x"));
             try
             {
                 writer.AddDocument(config.Build(taxoWriter, doc));
@@ -270,7 +270,7 @@ namespace Lucene.Net.Facet.Taxonomy
             q.Add("int", "b");
             searcher.Search(q, fc);
 
-            Facets facets = new TaxonomyFacetSumIntAssociations("$facets.int", taxoReader, config, fc);
+            Facets facets = new TaxonomyFacetSumInt32Associations("$facets.int", taxoReader, config, fc);
             Assert.AreEqual("dim=int path=[] value=-1 childCount=2\n  b (150)\n  a (100)\n", facets.GetTopChildren(10, "int").ToString());
             Assert.AreEqual(100, (int)facets.GetSpecificValue("int", "a"), "Wrong count for category 'a'!");
             Assert.AreEqual(150, (int)facets.GetSpecificValue("int", "b"), "Wrong count for category 'b'!");


Mime
View raw message