lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ccurr...@apache.org
Subject [Lucene.Net] svn commit: r1294875 [24/45] - in /incubator/lucene.net/trunk: ./ build/ build/vs2010/contrib/ build/vs2010/test/ doc/ src/ src/contrib/Analyzers/ src/contrib/Analyzers/AR/ src/contrib/Analyzers/BR/ src/contrib/Analyzers/CJK/ src/contrib/Analyzers/Cn/ ...
Date Tue, 28 Feb 2012 22:43:28 GMT
Modified: incubator/lucene.net/trunk/src/core/Search/FieldCacheRangeFilter.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/FieldCacheRangeFilter.cs?rev=1294875&r1=1294874&r2=1294875&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/FieldCacheRangeFilter.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/FieldCacheRangeFilter.cs Tue Feb 28 22:43:08 2012
@@ -16,7 +16,7 @@
  */
 
 using System;
-
+using Lucene.Net.Support;
 using NumericField = Lucene.Net.Documents.NumericField;
 using IndexReader = Lucene.Net.Index.IndexReader;
 using TermDocs = Lucene.Net.Index.TermDocs;
@@ -27,20 +27,19 @@ namespace Lucene.Net.Search
 	
 	/// <summary> A range filter built on top of a cached single term field (in <see cref="FieldCache" />).
 	/// 
-	/// <p/>FieldCacheRangeFilter builds a single cache for the field the first time it is used.
-	/// Each subsequent FieldCacheRangeFilter on the same field then reuses this cache,
+    /// <p/><see cref="FieldCacheRangeFilter" /> builds a single cache for the field the first time it is used.
+    /// Each subsequent <see cref="FieldCacheRangeFilter" /> on the same field then reuses this cache,
 	/// even if the range itself changes. 
 	/// 
-	/// <p/>This means that FieldCacheRangeFilter is much faster (sometimes more than 100x as fast) 
-	/// as building a <see cref="TermRangeFilter" /> (or <see cref="ConstantScoreRangeQuery" /> on a <see cref="TermRangeFilter" />)
-	/// for each query, if using a <see cref="NewStringRange" />. However, if the range never changes it
-	/// is slower (around 2x as slow) than building a CachingWrapperFilter on top of a single TermRangeFilter.
+    /// <p/>This means that <see cref="FieldCacheRangeFilter" /> is much faster (sometimes more than 100x as fast) 
+	/// as building a <see cref="TermRangeFilter" /> if using a <see cref="NewStringRange" />. However, if the range never changes it
+    /// is slower (around 2x as slow) than building a CachingWrapperFilter on top of a single <see cref="TermRangeFilter" />.
 	/// 
-	/// For numeric data types, this filter may be significantly faster than <see cref="NumericRangeFilter" />.
+	/// For numeric data types, this filter may be significantly faster than <see cref="NumericRangeFilter{T}" />.
 	/// Furthermore, it does not need the numeric values encoded by <see cref="NumericField" />. But
 	/// it has the problem that it only works with exact one value/document (see below).
 	/// 
-	/// <p/>As with all <see cref="FieldCache" /> based functionality, FieldCacheRangeFilter is only valid for 
+    /// <p/>As with all <see cref="FieldCache" /> based functionality, <see cref="FieldCacheRangeFilter" /> is only valid for 
 	/// fields which exact one term for each document (except for <see cref="NewStringRange" />
 	/// where 0 terms are also allowed). Due to a restriction of <see cref="FieldCache" />, for numeric ranges
 	/// all terms that do not have a numeric value, 0 is assumed.
@@ -53,546 +52,681 @@ namespace Lucene.Net.Search
 	/// that create a correct instance for different data types supported by <see cref="FieldCache" />.
 	/// </summary>
 	
+    public static class FieldCacheRangeFilter
+	{
+        [Serializable]
+        private class AnonymousClassFieldCacheRangeFilter : FieldCacheRangeFilter<string>
+        {
+            private class AnonymousClassFieldCacheDocIdSet : FieldCacheDocIdSet
+            {
+                private void InitBlock(Lucene.Net.Search.StringIndex fcsi, int inclusiveLowerPoint, int inclusiveUpperPoint, FieldCacheRangeFilter<string> enclosingInstance)
+                {
+                    this.fcsi = fcsi;
+                    this.inclusiveLowerPoint = inclusiveLowerPoint;
+                    this.inclusiveUpperPoint = inclusiveUpperPoint;
+                    this.enclosingInstance = enclosingInstance;
+                }
+                private Lucene.Net.Search.StringIndex fcsi;
+                private int inclusiveLowerPoint;
+                private int inclusiveUpperPoint;
+                private FieldCacheRangeFilter<string> enclosingInstance;
+                public FieldCacheRangeFilter<string> Enclosing_Instance
+                {
+                    get
+                    {
+                        return enclosingInstance;
+                    }
+
+                }
+                internal AnonymousClassFieldCacheDocIdSet(Lucene.Net.Search.StringIndex fcsi, int inclusiveLowerPoint, int inclusiveUpperPoint, FieldCacheRangeFilter<string> enclosingInstance, Lucene.Net.Index.IndexReader Param1, bool Param2)
+                    : base(Param1, Param2)
+                {
+                    InitBlock(fcsi, inclusiveLowerPoint, inclusiveUpperPoint, enclosingInstance);
+                }
+                internal override bool MatchDoc(int doc)
+                {
+                    return fcsi.order[doc] >= inclusiveLowerPoint && fcsi.order[doc] <= inclusiveUpperPoint;
+                }
+            }
+            internal AnonymousClassFieldCacheRangeFilter(string field, Lucene.Net.Search.Parser parser, string lowerVal, string upperVal, bool includeLower, bool includeUpper)
+                : base(field, parser, lowerVal, upperVal, includeLower, includeUpper)
+            {
+            }
+            public override DocIdSet GetDocIdSet(IndexReader reader)
+            {
+                Lucene.Net.Search.StringIndex fcsi = Lucene.Net.Search.FieldCache_Fields.DEFAULT.GetStringIndex(reader, field);
+                int lowerPoint = fcsi.BinarySearchLookup(lowerVal);
+                int upperPoint = fcsi.BinarySearchLookup(upperVal);
+
+                int inclusiveLowerPoint;
+                int inclusiveUpperPoint;
+
+                // Hints:
+                // * binarySearchLookup returns 0, if value was null.
+                // * the value is <0 if no exact hit was found, the returned value
+                //   is (-(insertion point) - 1)
+                if (lowerPoint == 0)
+                {
+                    System.Diagnostics.Debug.Assert(lowerVal == null);
+                    inclusiveLowerPoint = 1;
+                }
+                else if (includeLower && lowerPoint > 0)
+                {
+                    inclusiveLowerPoint = lowerPoint;
+                }
+                else if (lowerPoint > 0)
+                {
+                    inclusiveLowerPoint = lowerPoint + 1;
+                }
+                else
+                {
+                    inclusiveLowerPoint = System.Math.Max(1, -lowerPoint - 1);
+                }
+
+                if (upperPoint == 0)
+                {
+                    System.Diagnostics.Debug.Assert(upperVal == null);
+                    inclusiveUpperPoint = System.Int32.MaxValue;
+                }
+                else if (includeUpper && upperPoint > 0)
+                {
+                    inclusiveUpperPoint = upperPoint;
+                }
+                else if (upperPoint > 0)
+                {
+                    inclusiveUpperPoint = upperPoint - 1;
+                }
+                else
+                {
+                    inclusiveUpperPoint = -upperPoint - 2;
+                }
+
+                if (inclusiveUpperPoint <= 0 || inclusiveLowerPoint > inclusiveUpperPoint)
+                    return DocIdSet.EMPTY_DOCIDSET;
+
+                System.Diagnostics.Debug.Assert(inclusiveLowerPoint > 0 && inclusiveUpperPoint > 0);
+
+                // for this DocIdSet, we never need to use TermDocs,
+                // because deleted docs have an order of 0 (null entry in StringIndex)
+                return new AnonymousClassFieldCacheDocIdSet(fcsi, inclusiveLowerPoint, inclusiveUpperPoint, this, reader, false);
+            }
+        }
+        [Serializable]
+        private class AnonymousClassFieldCacheRangeFilter1 : FieldCacheRangeFilter<sbyte?>
+        {
+            private class AnonymousClassFieldCacheDocIdSet : FieldCacheDocIdSet
+            {
+                private void InitBlock(sbyte[] values, sbyte inclusiveLowerPoint, sbyte inclusiveUpperPoint, FieldCacheRangeFilter<sbyte?> enclosingInstance)
+                {
+                    this.values = values;
+                    this.inclusiveLowerPoint = inclusiveLowerPoint;
+                    this.inclusiveUpperPoint = inclusiveUpperPoint;
+                    this.enclosingInstance = enclosingInstance;
+                }
+                private sbyte[] values;
+                private sbyte inclusiveLowerPoint;
+                private sbyte inclusiveUpperPoint;
+                private FieldCacheRangeFilter<sbyte?> enclosingInstance;
+                public FieldCacheRangeFilter<sbyte?> Enclosing_Instance
+                {
+                    get
+                    {
+                        return enclosingInstance;
+                    }
+
+                }
+                internal AnonymousClassFieldCacheDocIdSet(sbyte[] values, sbyte inclusiveLowerPoint, sbyte inclusiveUpperPoint, FieldCacheRangeFilter<sbyte?> enclosingInstance, Lucene.Net.Index.IndexReader Param1, bool Param2)
+                    : base(Param1, Param2)
+                {
+                    InitBlock(values, inclusiveLowerPoint, inclusiveUpperPoint, enclosingInstance);
+                }
+                internal override bool MatchDoc(int doc)
+                {
+                    return values[doc] >= inclusiveLowerPoint && values[doc] <= inclusiveUpperPoint;
+                }
+            }
+            internal AnonymousClassFieldCacheRangeFilter1(string field, Parser parser, sbyte? lowerVal, sbyte? upperVal, bool includeLower, bool includeUpper)
+                : base(field, parser, lowerVal, upperVal, includeLower, includeUpper)
+            {
+            }
+            public override DocIdSet GetDocIdSet(IndexReader reader)
+            {
+                sbyte inclusiveLowerPoint;
+                sbyte inclusiveUpperPoint;
+                if (lowerVal != null)
+                {
+                    sbyte i = (sbyte)lowerVal;
+                    if (!includeLower && i == byte.MaxValue)
+                        return DocIdSet.EMPTY_DOCIDSET;
+                    inclusiveLowerPoint = (sbyte)(includeLower ? i : (i + 1));
+                }
+                else
+                {
+                    inclusiveLowerPoint = sbyte.MinValue;
+                }
+                if (upperVal != null)
+                {
+                    sbyte i = (sbyte)upperVal;
+                    if (!includeUpper && i == sbyte.MinValue)
+                        return DocIdSet.EMPTY_DOCIDSET;
+                    inclusiveUpperPoint = (sbyte)(includeUpper ? i : (i - 1));
+                }
+                else
+                {
+                    inclusiveUpperPoint = sbyte.MaxValue;
+                }
+
+                if (inclusiveLowerPoint > inclusiveUpperPoint)
+                    return DocIdSet.EMPTY_DOCIDSET;
+
+                sbyte[] values = Lucene.Net.Search.FieldCache_Fields.DEFAULT.GetBytes(reader, field, (Lucene.Net.Search.ByteParser)parser);
+                // we only request the usage of termDocs, if the range contains 0
+                return new AnonymousClassFieldCacheDocIdSet(values, inclusiveLowerPoint, inclusiveUpperPoint, this, reader, (inclusiveLowerPoint <= 0 && inclusiveUpperPoint >= 0));
+            }
+        }
+        [Serializable]
+        private class AnonymousClassFieldCacheRangeFilter2 : FieldCacheRangeFilter<short?>
+        {
+            private class AnonymousClassFieldCacheDocIdSet : FieldCacheDocIdSet
+            {
+                private void InitBlock(short[] values, short inclusiveLowerPoint, short inclusiveUpperPoint, FieldCacheRangeFilter<short?> enclosingInstance)
+                {
+                    this.values = values;
+                    this.inclusiveLowerPoint = inclusiveLowerPoint;
+                    this.inclusiveUpperPoint = inclusiveUpperPoint;
+                    this.enclosingInstance = enclosingInstance;
+                }
+                private short[] values;
+                private short inclusiveLowerPoint;
+                private short inclusiveUpperPoint;
+                private FieldCacheRangeFilter<short?> enclosingInstance;
+                public FieldCacheRangeFilter<short?> Enclosing_Instance
+                {
+                    get
+                    {
+                        return enclosingInstance;
+                    }
+
+                }
+                internal AnonymousClassFieldCacheDocIdSet(short[] values, short inclusiveLowerPoint, short inclusiveUpperPoint, FieldCacheRangeFilter<short?> enclosingInstance, Lucene.Net.Index.IndexReader Param1, bool Param2)
+                    : base(Param1, Param2)
+                {
+                    InitBlock(values, inclusiveLowerPoint, inclusiveUpperPoint, enclosingInstance);
+                }
+                internal override bool MatchDoc(int doc)
+                {
+                    return values[doc] >= inclusiveLowerPoint && values[doc] <= inclusiveUpperPoint;
+                }
+            }
+            internal AnonymousClassFieldCacheRangeFilter2(string field, Parser parser, short? lowerVal, short? upperVal, bool includeLower, bool includeUpper)
+                : base(field, parser, lowerVal, upperVal, includeLower, includeUpper)
+            {
+            }
+            public override DocIdSet GetDocIdSet(IndexReader reader)
+            {
+                short inclusiveLowerPoint;
+                short inclusiveUpperPoint;
+                if (lowerVal != null)
+                {
+                    short i = (short)lowerVal;
+                    if (!includeLower && i == short.MaxValue)
+                        return DocIdSet.EMPTY_DOCIDSET;
+                    inclusiveLowerPoint = (short)(includeLower ? i : (i + 1));
+                }
+                else
+                {
+                    inclusiveLowerPoint = short.MinValue;
+                }
+                if (upperVal != null)
+                {
+                    short i = (short)upperVal;
+                    if (!includeUpper && i == short.MinValue)
+                        return DocIdSet.EMPTY_DOCIDSET;
+                    inclusiveUpperPoint = (short)(includeUpper ? i : (i - 1));
+                }
+                else
+                {
+                    inclusiveUpperPoint = short.MaxValue;
+                }
+
+                if (inclusiveLowerPoint > inclusiveUpperPoint)
+                    return DocIdSet.EMPTY_DOCIDSET;
+
+                short[] values = Lucene.Net.Search.FieldCache_Fields.DEFAULT.GetShorts(reader, field, (Lucene.Net.Search.ShortParser)parser);
+                // we only request the usage of termDocs, if the range contains 0
+                return new AnonymousClassFieldCacheDocIdSet(values, inclusiveLowerPoint, inclusiveUpperPoint, this, reader, (inclusiveLowerPoint <= 0 && inclusiveUpperPoint >= 0));
+            }
+        }
+        [Serializable]
+        private class AnonymousClassFieldCacheRangeFilter3 : FieldCacheRangeFilter<int?>
+        {
+            private class AnonymousClassFieldCacheDocIdSet : FieldCacheDocIdSet
+            {
+                private void InitBlock(int[] values, int inclusiveLowerPoint, int inclusiveUpperPoint, FieldCacheRangeFilter<int?> enclosingInstance)
+                {
+                    this.values = values;
+                    this.inclusiveLowerPoint = inclusiveLowerPoint;
+                    this.inclusiveUpperPoint = inclusiveUpperPoint;
+                    this.enclosingInstance = enclosingInstance;
+                }
+                private int[] values;
+                private int inclusiveLowerPoint;
+                private int inclusiveUpperPoint;
+                private FieldCacheRangeFilter<int?> enclosingInstance;
+                public FieldCacheRangeFilter<int?> Enclosing_Instance
+                {
+                    get
+                    {
+                        return enclosingInstance;
+                    }
+
+                }
+                internal AnonymousClassFieldCacheDocIdSet(int[] values, int inclusiveLowerPoint, int inclusiveUpperPoint, FieldCacheRangeFilter<int?> enclosingInstance, Lucene.Net.Index.IndexReader Param1, bool Param2)
+                    : base(Param1, Param2)
+                {
+                    InitBlock(values, inclusiveLowerPoint, inclusiveUpperPoint, enclosingInstance);
+                }
+                internal override bool MatchDoc(int doc)
+                {
+                    return values[doc] >= inclusiveLowerPoint && values[doc] <= inclusiveUpperPoint;
+                }
+            }
+            internal AnonymousClassFieldCacheRangeFilter3(string field, Lucene.Net.Search.Parser parser, int? lowerVal, int? upperVal, bool includeLower, bool includeUpper)
+                : base(field, parser, lowerVal, upperVal, includeLower, includeUpper)
+            {
+            }
+            public override DocIdSet GetDocIdSet(IndexReader reader)
+            {
+                int inclusiveLowerPoint;
+                int inclusiveUpperPoint;
+                if (lowerVal != null)
+                {
+                    int i = (int)lowerVal;
+                    if (!includeLower && i == int.MaxValue)
+                        return DocIdSet.EMPTY_DOCIDSET;
+                    inclusiveLowerPoint = includeLower ? i : (i + 1);
+                }
+                else
+                {
+                    inclusiveLowerPoint = int.MinValue;
+                }
+                if (upperVal != null)
+                {
+                    int i = (int)upperVal;
+                    if (!includeUpper && i == int.MinValue)
+                        return DocIdSet.EMPTY_DOCIDSET;
+                    inclusiveUpperPoint = includeUpper ? i : (i - 1);
+                }
+                else
+                {
+                    inclusiveUpperPoint = int.MaxValue;
+                }
+
+                if (inclusiveLowerPoint > inclusiveUpperPoint)
+                    return DocIdSet.EMPTY_DOCIDSET;
+
+                int[] values = Lucene.Net.Search.FieldCache_Fields.DEFAULT.GetInts(reader, field, (Lucene.Net.Search.IntParser)parser);
+                // we only request the usage of termDocs, if the range contains 0
+                return new AnonymousClassFieldCacheDocIdSet(values, inclusiveLowerPoint, inclusiveUpperPoint, this, reader, (inclusiveLowerPoint <= 0 && inclusiveUpperPoint >= 0));
+            }
+        }
+        [Serializable]
+        private class AnonymousClassFieldCacheRangeFilter4 : FieldCacheRangeFilter<long?>
+        {
+            private class AnonymousClassFieldCacheDocIdSet : FieldCacheDocIdSet
+            {
+                private void InitBlock(long[] values, long inclusiveLowerPoint, long inclusiveUpperPoint, FieldCacheRangeFilter<long?> enclosingInstance)
+                {
+                    this.values = values;
+                    this.inclusiveLowerPoint = inclusiveLowerPoint;
+                    this.inclusiveUpperPoint = inclusiveUpperPoint;
+                    this.enclosingInstance = enclosingInstance;
+                }
+                private long[] values;
+                private long inclusiveLowerPoint;
+                private long inclusiveUpperPoint;
+                private FieldCacheRangeFilter<long?> enclosingInstance;
+                public FieldCacheRangeFilter<long?> Enclosing_Instance
+                {
+                    get
+                    {
+                        return enclosingInstance;
+                    }
+
+                }
+                internal AnonymousClassFieldCacheDocIdSet(long[] values, long inclusiveLowerPoint, long inclusiveUpperPoint, FieldCacheRangeFilter<long?> enclosingInstance, Lucene.Net.Index.IndexReader Param1, bool Param2)
+                    : base(Param1, Param2)
+                {
+                    InitBlock(values, inclusiveLowerPoint, inclusiveUpperPoint, enclosingInstance);
+                }
+                internal override bool MatchDoc(int doc)
+                {
+                    return values[doc] >= inclusiveLowerPoint && values[doc] <= inclusiveUpperPoint;
+                }
+            }
+            internal AnonymousClassFieldCacheRangeFilter4(string field, Lucene.Net.Search.Parser parser, long? lowerVal, long? upperVal, bool includeLower, bool includeUpper)
+                : base(field, parser, lowerVal, upperVal, includeLower, includeUpper)
+            {
+            }
+            public override DocIdSet GetDocIdSet(IndexReader reader)
+            {
+                long inclusiveLowerPoint;
+                long inclusiveUpperPoint;
+                if (lowerVal != null)
+                {
+                    long i = (long)lowerVal;
+                    if (!includeLower && i == long.MaxValue)
+                        return DocIdSet.EMPTY_DOCIDSET;
+                    inclusiveLowerPoint = includeLower ? i : (i + 1L);
+                }
+                else
+                {
+                    inclusiveLowerPoint = long.MinValue;
+                }
+                if (upperVal != null)
+                {
+                    long i = (long)upperVal;
+                    if (!includeUpper && i == long.MinValue)
+                        return DocIdSet.EMPTY_DOCIDSET;
+                    inclusiveUpperPoint = includeUpper ? i : (i - 1L);
+                }
+                else
+                {
+                    inclusiveUpperPoint = long.MaxValue;
+                }
+
+                if (inclusiveLowerPoint > inclusiveUpperPoint)
+                    return DocIdSet.EMPTY_DOCIDSET;
+
+                long[] values = Lucene.Net.Search.FieldCache_Fields.DEFAULT.GetLongs(reader, field, (Lucene.Net.Search.LongParser)parser);
+                // we only request the usage of termDocs, if the range contains 0
+                return new AnonymousClassFieldCacheDocIdSet(values, inclusiveLowerPoint, inclusiveUpperPoint, this, reader, (inclusiveLowerPoint <= 0L && inclusiveUpperPoint >= 0L));
+            }
+        }
+        [Serializable]
+        private class AnonymousClassFieldCacheRangeFilter5 : FieldCacheRangeFilter<float?>
+        {
+            private class AnonymousClassFieldCacheDocIdSet : FieldCacheDocIdSet
+            {
+                private void InitBlock(float[] values, float inclusiveLowerPoint, float inclusiveUpperPoint, FieldCacheRangeFilter<float?> enclosingInstance)
+                {
+                    this.values = values;
+                    this.inclusiveLowerPoint = inclusiveLowerPoint;
+                    this.inclusiveUpperPoint = inclusiveUpperPoint;
+                    this.enclosingInstance = enclosingInstance;
+                }
+                private float[] values;
+                private float inclusiveLowerPoint;
+                private float inclusiveUpperPoint;
+                private FieldCacheRangeFilter<float?> enclosingInstance;
+                public FieldCacheRangeFilter<float?> Enclosing_Instance
+                {
+                    get
+                    {
+                        return enclosingInstance;
+                    }
+
+                }
+                internal AnonymousClassFieldCacheDocIdSet(float[] values, float inclusiveLowerPoint, float inclusiveUpperPoint, FieldCacheRangeFilter<float?> enclosingInstance, Lucene.Net.Index.IndexReader Param1, bool Param2)
+                    : base(Param1, Param2)
+                {
+                    InitBlock(values, inclusiveLowerPoint, inclusiveUpperPoint, enclosingInstance);
+                }
+                internal override bool MatchDoc(int doc)
+                {
+                    return values[doc] >= inclusiveLowerPoint && values[doc] <= inclusiveUpperPoint;
+                }
+            }
+            internal AnonymousClassFieldCacheRangeFilter5(string field, Lucene.Net.Search.Parser parser, float? lowerVal, float? upperVal, bool includeLower, bool includeUpper)
+                : base(field, parser, lowerVal, upperVal, includeLower, includeUpper)
+            {
+            }
+            public override DocIdSet GetDocIdSet(IndexReader reader)
+            {
+                // we transform the floating point numbers to sortable integers
+                // using NumericUtils to easier find the next bigger/lower value
+                float inclusiveLowerPoint;
+                float inclusiveUpperPoint;
+                if (lowerVal != null)
+                {
+                    float f = (float)lowerVal;
+                    if (!includeUpper && f > 0.0f && float.IsInfinity(f))
+                        return DocIdSet.EMPTY_DOCIDSET;
+                    int i = NumericUtils.FloatToSortableInt(f);
+                    inclusiveLowerPoint = NumericUtils.SortableIntToFloat(includeLower ? i : (i + 1));
+                }
+                else
+                {
+                    inclusiveLowerPoint = float.NegativeInfinity;
+                }
+                if (upperVal != null)
+                {
+                    float f = (float)upperVal;
+                    if (!includeUpper && f < 0.0f && float.IsInfinity(f))
+                        return DocIdSet.EMPTY_DOCIDSET;
+                    int i = NumericUtils.FloatToSortableInt(f);
+                    inclusiveUpperPoint = NumericUtils.SortableIntToFloat(includeUpper ? i : (i - 1));
+                }
+                else
+                {
+                    inclusiveUpperPoint = float.PositiveInfinity;
+                }
+
+                if (inclusiveLowerPoint > inclusiveUpperPoint)
+                    return DocIdSet.EMPTY_DOCIDSET;
+
+                float[] values = Lucene.Net.Search.FieldCache_Fields.DEFAULT.GetFloats(reader, field, (Lucene.Net.Search.FloatParser)parser);
+                // we only request the usage of termDocs, if the range contains 0
+                return new AnonymousClassFieldCacheDocIdSet(values, inclusiveLowerPoint, inclusiveUpperPoint, this, reader, (inclusiveLowerPoint <= 0.0f && inclusiveUpperPoint >= 0.0f));
+            }
+        }
+        [Serializable]
+        private class AnonymousClassFieldCacheRangeFilter6 : FieldCacheRangeFilter<double?>
+        {
+            private class AnonymousClassFieldCacheDocIdSet : FieldCacheDocIdSet
+            {
+                private void InitBlock(double[] values, double inclusiveLowerPoint, double inclusiveUpperPoint, FieldCacheRangeFilter<double?> enclosingInstance)
+                {
+                    this.values = values;
+                    this.inclusiveLowerPoint = inclusiveLowerPoint;
+                    this.inclusiveUpperPoint = inclusiveUpperPoint;
+                    this.enclosingInstance = enclosingInstance;
+                }
+                private double[] values;
+                private double inclusiveLowerPoint;
+                private double inclusiveUpperPoint;
+                private FieldCacheRangeFilter<double?> enclosingInstance;
+                public FieldCacheRangeFilter<double?> Enclosing_Instance
+                {
+                    get
+                    {
+                        return enclosingInstance;
+                    }
+
+                }
+                internal AnonymousClassFieldCacheDocIdSet(double[] values, double inclusiveLowerPoint, double inclusiveUpperPoint, FieldCacheRangeFilter<double?> enclosingInstance, Lucene.Net.Index.IndexReader Param1, bool Param2)
+                    : base(Param1, Param2)
+                {
+                    InitBlock(values, inclusiveLowerPoint, inclusiveUpperPoint, enclosingInstance);
+                }
+                internal override bool MatchDoc(int doc)
+                {
+                    return values[doc] >= inclusiveLowerPoint && values[doc] <= inclusiveUpperPoint;
+                }
+            }
+            internal AnonymousClassFieldCacheRangeFilter6(string field, Lucene.Net.Search.Parser parser, double? lowerVal, double? upperVal, bool includeLower, bool includeUpper)
+                : base(field, parser, lowerVal, upperVal, includeLower, includeUpper)
+            {
+            }
+            public override DocIdSet GetDocIdSet(IndexReader reader)
+            {
+                // we transform the floating point numbers to sortable integers
+                // using NumericUtils to easier find the next bigger/lower value
+                double inclusiveLowerPoint;
+                double inclusiveUpperPoint;
+                if (lowerVal != null)
+                {
+                    double f = (double)lowerVal;
+                    if (!includeUpper && f > 0.0 && double.IsInfinity(f))
+                        return DocIdSet.EMPTY_DOCIDSET;
+                    long i = NumericUtils.DoubleToSortableLong(f);
+                    inclusiveLowerPoint = NumericUtils.SortableLongToDouble(includeLower ? i : (i + 1L));
+                }
+                else
+                {
+                    inclusiveLowerPoint = double.NegativeInfinity;
+                }
+                if (upperVal != null)
+                {
+                    double f = (double)upperVal;
+                    if (!includeUpper && f < 0.0 && double.IsInfinity(f))
+                        return DocIdSet.EMPTY_DOCIDSET;
+                    long i = NumericUtils.DoubleToSortableLong(f);
+                    inclusiveUpperPoint = NumericUtils.SortableLongToDouble(includeUpper ? i : (i - 1L));
+                }
+                else
+                {
+                    inclusiveUpperPoint = double.PositiveInfinity;
+                }
+
+                if (inclusiveLowerPoint > inclusiveUpperPoint)
+                    return DocIdSet.EMPTY_DOCIDSET;
+
+                double[] values = Lucene.Net.Search.FieldCache_Fields.DEFAULT.GetDoubles(reader, field, (Lucene.Net.Search.DoubleParser)parser);
+                // we only request the usage of termDocs, if the range contains 0
+                return new AnonymousClassFieldCacheDocIdSet(values, inclusiveLowerPoint, inclusiveUpperPoint, this, reader, (inclusiveLowerPoint <= 0.0 && inclusiveUpperPoint >= 0.0));
+            }
+        }
+
+        /// <summary> Creates a string range filter using <see cref="FieldCache.GetStringIndex(IndexReader,string)" />. This works with all
+        /// fields containing zero or one term in the field. The range can be half-open by setting one
+        /// of the values to <c>null</c>.
+        /// </summary>
+        public static FieldCacheRangeFilter<string> NewStringRange(string field, string lowerVal, string upperVal, bool includeLower, bool includeUpper)
+        {
+            return new AnonymousClassFieldCacheRangeFilter(field, null, lowerVal, upperVal, includeLower, includeUpper);
+        }
+
+        /// <summary> Creates a numeric range filter using <see cref="FieldCache.GetBytes(IndexReader,String)" />. This works with all
+        /// byte fields containing exactly one numeric term in the field. The range can be half-open by setting one
+        /// of the values to <c>null</c>.
+        /// </summary>
+        public static FieldCacheRangeFilter<sbyte?> NewByteRange(string field, sbyte? lowerVal, sbyte? upperVal, bool includeLower, bool includeUpper)
+        {
+            return NewByteRange(field, null, lowerVal, upperVal, includeLower, includeUpper);
+        }
+
+        /// <summary> Creates a numeric range filter using <see cref="FieldCache.GetBytes(IndexReader,String,ByteParser)" />. This works with all
+        /// byte fields containing exactly one numeric term in the field. The range can be half-open by setting one
+        /// of the values to <c>null</c>.
+        /// </summary>
+        public static FieldCacheRangeFilter<sbyte?> NewByteRange(string field, Lucene.Net.Search.ByteParser parser, sbyte? lowerVal, sbyte? upperVal, bool includeLower, bool includeUpper)
+        {
+            return new AnonymousClassFieldCacheRangeFilter1(field, parser, lowerVal, upperVal, includeLower, includeUpper);
+        }
+
+        /// <summary> Creates a numeric range query using <see cref="FieldCache.GetShorts(IndexReader,String)" />. This works with all
+        /// short fields containing exactly one numeric term in the field. The range can be half-open by setting one
+        /// of the values to <c>null</c>.
+        /// </summary>
+        public static FieldCacheRangeFilter<short?> NewShortRange(string field, short? lowerVal, short? upperVal, bool includeLower, bool includeUpper)
+        {
+            return NewShortRange(field, null, lowerVal, upperVal, includeLower, includeUpper);
+        }
+
+        /// <summary> Creates a numeric range query using <see cref="FieldCache.GetShorts(IndexReader,String,ShortParser)" />. This works with all
+        /// short fields containing exactly one numeric term in the field. The range can be half-open by setting one
+        /// of the values to <c>null</c>.
+        /// </summary>
+        public static FieldCacheRangeFilter<short?> NewShortRange(string field, Lucene.Net.Search.ShortParser parser, short? lowerVal, short? upperVal, bool includeLower, bool includeUpper)
+        {
+            return new AnonymousClassFieldCacheRangeFilter2(field, parser, lowerVal, upperVal, includeLower, includeUpper);
+        }
+
+        /// <summary> Creates a numeric range query using <see cref="FieldCache.GetInts(IndexReader,String)" />. This works with all
+        /// int fields containing exactly one numeric term in the field. The range can be half-open by setting one
+        /// of the values to <c>null</c>.
+        /// </summary>
+        public static FieldCacheRangeFilter<int?> NewIntRange(string field, int? lowerVal, int? upperVal, bool includeLower, bool includeUpper)
+        {
+            return NewIntRange(field, null, lowerVal, upperVal, includeLower, includeUpper);
+        }
+
+        /// <summary> Creates a numeric range query using <see cref="FieldCache.GetInts(IndexReader,String,IntParser)" />. This works with all
+        /// int fields containing exactly one numeric term in the field. The range can be half-open by setting one
+        /// of the values to <c>null</c>.
+        /// </summary>
+        public static FieldCacheRangeFilter<int?> NewIntRange(string field, Lucene.Net.Search.IntParser parser, int? lowerVal, int? upperVal, bool includeLower, bool includeUpper)
+        {
+            return new AnonymousClassFieldCacheRangeFilter3(field, parser, lowerVal, upperVal, includeLower, includeUpper);
+        }
+
+        /// <summary> Creates a numeric range query using <see cref="FieldCache.GetLongs(IndexReader,String)" />. This works with all
+        /// long fields containing exactly one numeric term in the field. The range can be half-open by setting one
+        /// of the values to <c>null</c>.
+        /// </summary>
+        public static FieldCacheRangeFilter<long?> NewLongRange(string field, long? lowerVal, long? upperVal, bool includeLower, bool includeUpper)
+        {
+            return NewLongRange(field, null, lowerVal, upperVal, includeLower, includeUpper);
+        }
+
+        /// <summary> Creates a numeric range query using <see cref="FieldCache.GetLongs(IndexReader,String,LongParser)" />. This works with all
+        /// long fields containing exactly one numeric term in the field. The range can be half-open by setting one
+        /// of the values to <c>null</c>.
+        /// </summary>
+        public static FieldCacheRangeFilter<long?> NewLongRange(string field, Lucene.Net.Search.LongParser parser, long? lowerVal, long? upperVal, bool includeLower, bool includeUpper)
+        {
+            return new AnonymousClassFieldCacheRangeFilter4(field, parser, lowerVal, upperVal, includeLower, includeUpper);
+        }
+
+        /// <summary> Creates a numeric range query using <see cref="FieldCache.GetFloats(IndexReader,String)" />. This works with all
+        /// float fields containing exactly one numeric term in the field. The range can be half-open by setting one
+        /// of the values to <c>null</c>.
+        /// </summary>
+        public static FieldCacheRangeFilter<float?> NewFloatRange(string field, float? lowerVal, float? upperVal, bool includeLower, bool includeUpper)
+        {
+            return NewFloatRange(field, null, lowerVal, upperVal, includeLower, includeUpper);
+        }
+
+        /// <summary> Creates a numeric range query using <see cref="FieldCache.GetFloats(IndexReader,String,FloatParser)" />. This works with all
+        /// float fields containing exactly one numeric term in the field. The range can be half-open by setting one
+        /// of the values to <c>null</c>.
+        /// </summary>
+        public static FieldCacheRangeFilter<float?> NewFloatRange(string field, Lucene.Net.Search.FloatParser parser, float? lowerVal, float? upperVal, bool includeLower, bool includeUpper)
+        {
+            return new AnonymousClassFieldCacheRangeFilter5(field, parser, lowerVal, upperVal, includeLower, includeUpper);
+        }
+
+        /// <summary> Creates a numeric range query using <see cref="FieldCache.GetDoubles(IndexReader,String)" />. This works with all
+        /// double fields containing exactly one numeric term in the field. The range can be half-open by setting one
+        /// of the values to <c>null</c>.
+        /// </summary>
+        public static FieldCacheRangeFilter<double?> NewDoubleRange(string field, double? lowerVal, double? upperVal, bool includeLower, bool includeUpper)
+        {
+            return NewDoubleRange(field, null, lowerVal, upperVal, includeLower, includeUpper);
+        }
+
+        /// <summary> Creates a numeric range query using <see cref="FieldCache.GetDoubles(IndexReader,String,DoubleParser)" />. This works with all
+        /// double fields containing exactly one numeric term in the field. The range can be half-open by setting one
+        /// of the values to <c>null</c>.
+        /// </summary>
+        public static FieldCacheRangeFilter<double?> NewDoubleRange(string field, Lucene.Net.Search.DoubleParser parser, double? lowerVal, double? upperVal, bool includeLower, bool includeUpper)
+        {
+            return new AnonymousClassFieldCacheRangeFilter6(field, parser, lowerVal, upperVal, includeLower, includeUpper);
+        }
+	}
+
 	[Serializable]
-	public abstract class FieldCacheRangeFilter:Filter
+	public abstract class FieldCacheRangeFilter<T> : Filter
 	{
-		[Serializable]
-		private class AnonymousClassFieldCacheRangeFilter:FieldCacheRangeFilter
-		{
-			private class AnonymousClassFieldCacheDocIdSet:FieldCacheDocIdSet
-			{
-				private void  InitBlock(Lucene.Net.Search.StringIndex fcsi, int inclusiveLowerPoint, int inclusiveUpperPoint, AnonymousClassFieldCacheRangeFilter enclosingInstance)
-				{
-					this.fcsi = fcsi;
-					this.inclusiveLowerPoint = inclusiveLowerPoint;
-					this.inclusiveUpperPoint = inclusiveUpperPoint;
-					this.enclosingInstance = enclosingInstance;
-				}
-				private Lucene.Net.Search.StringIndex fcsi;
-				private int inclusiveLowerPoint;
-				private int inclusiveUpperPoint;
-				private AnonymousClassFieldCacheRangeFilter enclosingInstance;
-				public AnonymousClassFieldCacheRangeFilter Enclosing_Instance
-				{
-					get
-					{
-						return enclosingInstance;
-					}
-					
-				}
-				internal AnonymousClassFieldCacheDocIdSet(Lucene.Net.Search.StringIndex fcsi, int inclusiveLowerPoint, int inclusiveUpperPoint, AnonymousClassFieldCacheRangeFilter enclosingInstance, Lucene.Net.Index.IndexReader Param1, bool Param2):base(Param1, Param2)
-				{
-					InitBlock(fcsi, inclusiveLowerPoint, inclusiveUpperPoint, enclosingInstance);
-				}
-				internal override bool MatchDoc(int doc)
-				{
-					return fcsi.order[doc] >= inclusiveLowerPoint && fcsi.order[doc] <= inclusiveUpperPoint;
-				}
-			}
-			internal AnonymousClassFieldCacheRangeFilter(System.String Param1, Lucene.Net.Search.Parser Param2, System.Object Param3, System.Object Param4, bool Param5, bool Param6):base(Param1, Param2, Param3, Param4, Param5, Param6)
-			{
-			}
-			public override DocIdSet GetDocIdSet(IndexReader reader)
-			{
-				Lucene.Net.Search.StringIndex fcsi = Lucene.Net.Search.FieldCache_Fields.DEFAULT.GetStringIndex(reader, field);
-				int lowerPoint = fcsi.BinarySearchLookup((System.String) lowerVal);
-				int upperPoint = fcsi.BinarySearchLookup((System.String) upperVal);
-				
-				int inclusiveLowerPoint;
-				int inclusiveUpperPoint;
-				
-				// Hints:
-				// * binarySearchLookup returns 0, if value was null.
-				// * the value is <0 if no exact hit was found, the returned value
-				//   is (-(insertion point) - 1)
-				if (lowerPoint == 0)
-				{
-					System.Diagnostics.Debug.Assert(lowerVal == null);
-					inclusiveLowerPoint = 1;
-				}
-				else if (includeLower && lowerPoint > 0)
-				{
-					inclusiveLowerPoint = lowerPoint;
-				}
-				else if (lowerPoint > 0)
-				{
-					inclusiveLowerPoint = lowerPoint + 1;
-				}
-				else
-				{
-					inclusiveLowerPoint = System.Math.Max(1, - lowerPoint - 1);
-				}
-				
-				if (upperPoint == 0)
-				{
-					System.Diagnostics.Debug.Assert(upperVal == null);
-					inclusiveUpperPoint = System.Int32.MaxValue;
-				}
-				else if (includeUpper && upperPoint > 0)
-				{
-					inclusiveUpperPoint = upperPoint;
-				}
-				else if (upperPoint > 0)
-				{
-					inclusiveUpperPoint = upperPoint - 1;
-				}
-				else
-				{
-					inclusiveUpperPoint = - upperPoint - 2;
-				}
-				
-				if (inclusiveUpperPoint <= 0 || inclusiveLowerPoint > inclusiveUpperPoint)
-					return DocIdSet.EMPTY_DOCIDSET;
-				
-				System.Diagnostics.Debug.Assert(inclusiveLowerPoint > 0 && inclusiveUpperPoint > 0);
-				
-				// for this DocIdSet, we never need to use TermDocs,
-				// because deleted docs have an order of 0 (null entry in StringIndex)
-				return new AnonymousClassFieldCacheDocIdSet(fcsi, inclusiveLowerPoint, inclusiveUpperPoint, this, reader, false);
-			}
-		}
-		[Serializable]
-		private class AnonymousClassFieldCacheRangeFilter1:FieldCacheRangeFilter
-		{
-			private class AnonymousClassFieldCacheDocIdSet:FieldCacheDocIdSet
-			{
-				private void  InitBlock(sbyte[] values, byte inclusiveLowerPoint, byte inclusiveUpperPoint, AnonymousClassFieldCacheRangeFilter1 enclosingInstance)
-				{
-					this.values = values;
-					this.inclusiveLowerPoint = inclusiveLowerPoint;
-					this.inclusiveUpperPoint = inclusiveUpperPoint;
-					this.enclosingInstance = enclosingInstance;
-				}
-				private sbyte[] values;
-				private byte inclusiveLowerPoint;
-				private byte inclusiveUpperPoint;
-				private AnonymousClassFieldCacheRangeFilter1 enclosingInstance;
-				public AnonymousClassFieldCacheRangeFilter1 Enclosing_Instance
-				{
-					get
-					{
-						return enclosingInstance;
-					}
-					
-				}
-				internal AnonymousClassFieldCacheDocIdSet(sbyte[] values, byte inclusiveLowerPoint, byte inclusiveUpperPoint, AnonymousClassFieldCacheRangeFilter1 enclosingInstance, Lucene.Net.Index.IndexReader Param1, bool Param2):base(Param1, Param2)
-				{
-					InitBlock(values, inclusiveLowerPoint, inclusiveUpperPoint, enclosingInstance);
-				}
-				internal override bool MatchDoc(int doc)
-				{
-					return values[doc] >= inclusiveLowerPoint && values[doc] <= inclusiveUpperPoint;
-				}
-			}
-			internal AnonymousClassFieldCacheRangeFilter1(System.String Param1, Lucene.Net.Search.Parser Param2, System.Object Param3, System.Object Param4, bool Param5, bool Param6):base(Param1, Param2, Param3, Param4, Param5, Param6)
-			{
-			}
-			public override DocIdSet GetDocIdSet(IndexReader reader)
-			{
-				byte inclusiveLowerPoint;
-				byte inclusiveUpperPoint;
-				if (lowerVal != null)
-				{
-					byte i = (byte) System.Convert.ToSByte(((System.ValueType) lowerVal));
-					if (!includeLower && i == (byte) System.Byte.MaxValue)
-						return DocIdSet.EMPTY_DOCIDSET;
-					inclusiveLowerPoint = (byte) (includeLower?i:(i + 1));
-				}
-				else
-				{
-					inclusiveLowerPoint = (byte) System.Byte.MinValue;
-				}
-				if (upperVal != null)
-				{
-					byte i = (byte) System.Convert.ToSByte(((System.ValueType) upperVal));
-					if (!includeUpper && i == (byte) System.Byte.MinValue)
-						return DocIdSet.EMPTY_DOCIDSET;
-					inclusiveUpperPoint = (byte) (includeUpper?i:(i - 1));
-				}
-				else
-				{
-					inclusiveUpperPoint = (byte) System.Byte.MaxValue;
-				}
-				
-				if (inclusiveLowerPoint > inclusiveUpperPoint)
-					return DocIdSet.EMPTY_DOCIDSET;
-				
-				sbyte[] values = Lucene.Net.Search.FieldCache_Fields.DEFAULT.GetBytes(reader, field, (Lucene.Net.Search.ByteParser) parser);
-				// we only request the usage of termDocs, if the range contains 0
-				return new AnonymousClassFieldCacheDocIdSet(values, inclusiveLowerPoint, inclusiveUpperPoint, this, reader, (inclusiveLowerPoint <= 0 && inclusiveUpperPoint >= 0));
-			}
-		}
-		[Serializable]
-		private class AnonymousClassFieldCacheRangeFilter2:FieldCacheRangeFilter
-		{
-			private class AnonymousClassFieldCacheDocIdSet:FieldCacheDocIdSet
-			{
-				private void  InitBlock(short[] values, short inclusiveLowerPoint, short inclusiveUpperPoint, AnonymousClassFieldCacheRangeFilter2 enclosingInstance)
-				{
-					this.values = values;
-					this.inclusiveLowerPoint = inclusiveLowerPoint;
-					this.inclusiveUpperPoint = inclusiveUpperPoint;
-					this.enclosingInstance = enclosingInstance;
-				}
-				private short[] values;
-				private short inclusiveLowerPoint;
-				private short inclusiveUpperPoint;
-				private AnonymousClassFieldCacheRangeFilter2 enclosingInstance;
-				public AnonymousClassFieldCacheRangeFilter2 Enclosing_Instance
-				{
-					get
-					{
-						return enclosingInstance;
-					}
-					
-				}
-				internal AnonymousClassFieldCacheDocIdSet(short[] values, short inclusiveLowerPoint, short inclusiveUpperPoint, AnonymousClassFieldCacheRangeFilter2 enclosingInstance, Lucene.Net.Index.IndexReader Param1, bool Param2):base(Param1, Param2)
-				{
-					InitBlock(values, inclusiveLowerPoint, inclusiveUpperPoint, enclosingInstance);
-				}
-				internal override bool MatchDoc(int doc)
-				{
-					return values[doc] >= inclusiveLowerPoint && values[doc] <= inclusiveUpperPoint;
-				}
-			}
-			internal AnonymousClassFieldCacheRangeFilter2(System.String Param1, Lucene.Net.Search.Parser Param2, System.Object Param3, System.Object Param4, bool Param5, bool Param6):base(Param1, Param2, Param3, Param4, Param5, Param6)
-			{
-			}
-			public override DocIdSet GetDocIdSet(IndexReader reader)
-			{
-				short inclusiveLowerPoint;
-				short inclusiveUpperPoint;
-				if (lowerVal != null)
-				{
-					short i = System.Convert.ToInt16(((System.ValueType) lowerVal));
-					if (!includeLower && i == System.Int16.MaxValue)
-						return DocIdSet.EMPTY_DOCIDSET;
-					inclusiveLowerPoint = (short) (includeLower?i:(i + 1));
-				}
-				else
-				{
-					inclusiveLowerPoint = System.Int16.MinValue;
-				}
-				if (upperVal != null)
-				{
-					short i = System.Convert.ToInt16(((System.ValueType) upperVal));
-					if (!includeUpper && i == System.Int16.MinValue)
-						return DocIdSet.EMPTY_DOCIDSET;
-					inclusiveUpperPoint = (short) (includeUpper?i:(i - 1));
-				}
-				else
-				{
-					inclusiveUpperPoint = System.Int16.MaxValue;
-				}
-				
-				if (inclusiveLowerPoint > inclusiveUpperPoint)
-					return DocIdSet.EMPTY_DOCIDSET;
-				
-				short[] values = Lucene.Net.Search.FieldCache_Fields.DEFAULT.GetShorts(reader, field, (Lucene.Net.Search.ShortParser) parser);
-				// we only request the usage of termDocs, if the range contains 0
-				return new AnonymousClassFieldCacheDocIdSet(values, inclusiveLowerPoint, inclusiveUpperPoint, this, reader, (inclusiveLowerPoint <= 0 && inclusiveUpperPoint >= 0));
-			}
-		}
-		[Serializable]
-		private class AnonymousClassFieldCacheRangeFilter3:FieldCacheRangeFilter
-		{
-			private class AnonymousClassFieldCacheDocIdSet:FieldCacheDocIdSet
-			{
-				private void  InitBlock(int[] values, int inclusiveLowerPoint, int inclusiveUpperPoint, AnonymousClassFieldCacheRangeFilter3 enclosingInstance)
-				{
-					this.values = values;
-					this.inclusiveLowerPoint = inclusiveLowerPoint;
-					this.inclusiveUpperPoint = inclusiveUpperPoint;
-					this.enclosingInstance = enclosingInstance;
-				}
-				private int[] values;
-				private int inclusiveLowerPoint;
-				private int inclusiveUpperPoint;
-				private AnonymousClassFieldCacheRangeFilter3 enclosingInstance;
-				public AnonymousClassFieldCacheRangeFilter3 Enclosing_Instance
-				{
-					get
-					{
-						return enclosingInstance;
-					}
-					
-				}
-				internal AnonymousClassFieldCacheDocIdSet(int[] values, int inclusiveLowerPoint, int inclusiveUpperPoint, AnonymousClassFieldCacheRangeFilter3 enclosingInstance, Lucene.Net.Index.IndexReader Param1, bool Param2):base(Param1, Param2)
-				{
-					InitBlock(values, inclusiveLowerPoint, inclusiveUpperPoint, enclosingInstance);
-				}
-				internal override bool MatchDoc(int doc)
-				{
-					return values[doc] >= inclusiveLowerPoint && values[doc] <= inclusiveUpperPoint;
-				}
-			}
-			internal AnonymousClassFieldCacheRangeFilter3(System.String Param1, Lucene.Net.Search.Parser Param2, System.Object Param3, System.Object Param4, bool Param5, bool Param6):base(Param1, Param2, Param3, Param4, Param5, Param6)
-			{
-			}
-			public override DocIdSet GetDocIdSet(IndexReader reader)
-			{
-				int inclusiveLowerPoint;
-				int inclusiveUpperPoint;
-				if (lowerVal != null)
-				{
-					int i = System.Convert.ToInt32(((System.ValueType) lowerVal));
-					if (!includeLower && i == System.Int32.MaxValue)
-						return DocIdSet.EMPTY_DOCIDSET;
-					inclusiveLowerPoint = includeLower?i:(i + 1);
-				}
-				else
-				{
-					inclusiveLowerPoint = System.Int32.MinValue;
-				}
-				if (upperVal != null)
-				{
-					int i = System.Convert.ToInt32(((System.ValueType) upperVal));
-					if (!includeUpper && i == System.Int32.MinValue)
-						return DocIdSet.EMPTY_DOCIDSET;
-					inclusiveUpperPoint = includeUpper?i:(i - 1);
-				}
-				else
-				{
-					inclusiveUpperPoint = System.Int32.MaxValue;
-				}
-				
-				if (inclusiveLowerPoint > inclusiveUpperPoint)
-					return DocIdSet.EMPTY_DOCIDSET;
-				
-				int[] values = Lucene.Net.Search.FieldCache_Fields.DEFAULT.GetInts(reader, field, (Lucene.Net.Search.IntParser) parser);
-				// we only request the usage of termDocs, if the range contains 0
-				return new AnonymousClassFieldCacheDocIdSet(values, inclusiveLowerPoint, inclusiveUpperPoint, this, reader, (inclusiveLowerPoint <= 0 && inclusiveUpperPoint >= 0));
-			}
-		}
-		[Serializable]
-		private class AnonymousClassFieldCacheRangeFilter4:FieldCacheRangeFilter
-		{
-			private class AnonymousClassFieldCacheDocIdSet:FieldCacheDocIdSet
-			{
-				private void  InitBlock(long[] values, long inclusiveLowerPoint, long inclusiveUpperPoint, AnonymousClassFieldCacheRangeFilter4 enclosingInstance)
-				{
-					this.values = values;
-					this.inclusiveLowerPoint = inclusiveLowerPoint;
-					this.inclusiveUpperPoint = inclusiveUpperPoint;
-					this.enclosingInstance = enclosingInstance;
-				}
-				private long[] values;
-				private long inclusiveLowerPoint;
-				private long inclusiveUpperPoint;
-				private AnonymousClassFieldCacheRangeFilter4 enclosingInstance;
-				public AnonymousClassFieldCacheRangeFilter4 Enclosing_Instance
-				{
-					get
-					{
-						return enclosingInstance;
-					}
-					
-				}
-				internal AnonymousClassFieldCacheDocIdSet(long[] values, long inclusiveLowerPoint, long inclusiveUpperPoint, AnonymousClassFieldCacheRangeFilter4 enclosingInstance, Lucene.Net.Index.IndexReader Param1, bool Param2):base(Param1, Param2)
-				{
-					InitBlock(values, inclusiveLowerPoint, inclusiveUpperPoint, enclosingInstance);
-				}
-				internal override bool MatchDoc(int doc)
-				{
-					return values[doc] >= inclusiveLowerPoint && values[doc] <= inclusiveUpperPoint;
-				}
-			}
-			internal AnonymousClassFieldCacheRangeFilter4(System.String Param1, Lucene.Net.Search.Parser Param2, System.Object Param3, System.Object Param4, bool Param5, bool Param6):base(Param1, Param2, Param3, Param4, Param5, Param6)
-			{
-			}
-			public override DocIdSet GetDocIdSet(IndexReader reader)
-			{
-				long inclusiveLowerPoint;
-				long inclusiveUpperPoint;
-				if (lowerVal != null)
-				{
-					long i = System.Convert.ToInt64(((System.ValueType) lowerVal));
-					if (!includeLower && i == System.Int64.MaxValue)
-						return DocIdSet.EMPTY_DOCIDSET;
-					inclusiveLowerPoint = includeLower?i:(i + 1L);
-				}
-				else
-				{
-					inclusiveLowerPoint = System.Int64.MinValue;
-				}
-				if (upperVal != null)
-				{
-					long i = System.Convert.ToInt64(((System.ValueType) upperVal));
-					if (!includeUpper && i == System.Int64.MinValue)
-						return DocIdSet.EMPTY_DOCIDSET;
-					inclusiveUpperPoint = includeUpper?i:(i - 1L);
-				}
-				else
-				{
-					inclusiveUpperPoint = System.Int64.MaxValue;
-				}
-				
-				if (inclusiveLowerPoint > inclusiveUpperPoint)
-					return DocIdSet.EMPTY_DOCIDSET;
-				
-				long[] values = Lucene.Net.Search.FieldCache_Fields.DEFAULT.GetLongs(reader, field, (Lucene.Net.Search.LongParser) parser);
-				// we only request the usage of termDocs, if the range contains 0
-				return new AnonymousClassFieldCacheDocIdSet(values, inclusiveLowerPoint, inclusiveUpperPoint, this, reader, (inclusiveLowerPoint <= 0L && inclusiveUpperPoint >= 0L));
-			}
-		}
-		[Serializable]
-		private class AnonymousClassFieldCacheRangeFilter5:FieldCacheRangeFilter
-		{
-			private class AnonymousClassFieldCacheDocIdSet:FieldCacheDocIdSet
-			{
-				private void  InitBlock(float[] values, float inclusiveLowerPoint, float inclusiveUpperPoint, AnonymousClassFieldCacheRangeFilter5 enclosingInstance)
-				{
-					this.values = values;
-					this.inclusiveLowerPoint = inclusiveLowerPoint;
-					this.inclusiveUpperPoint = inclusiveUpperPoint;
-					this.enclosingInstance = enclosingInstance;
-				}
-				private float[] values;
-				private float inclusiveLowerPoint;
-				private float inclusiveUpperPoint;
-				private AnonymousClassFieldCacheRangeFilter5 enclosingInstance;
-				public AnonymousClassFieldCacheRangeFilter5 Enclosing_Instance
-				{
-					get
-					{
-						return enclosingInstance;
-					}
-					
-				}
-				internal AnonymousClassFieldCacheDocIdSet(float[] values, float inclusiveLowerPoint, float inclusiveUpperPoint, AnonymousClassFieldCacheRangeFilter5 enclosingInstance, Lucene.Net.Index.IndexReader Param1, bool Param2):base(Param1, Param2)
-				{
-					InitBlock(values, inclusiveLowerPoint, inclusiveUpperPoint, enclosingInstance);
-				}
-				internal override bool MatchDoc(int doc)
-				{
-					return values[doc] >= inclusiveLowerPoint && values[doc] <= inclusiveUpperPoint;
-				}
-			}
-			internal AnonymousClassFieldCacheRangeFilter5(System.String Param1, Lucene.Net.Search.Parser Param2, System.Object Param3, System.Object Param4, bool Param5, bool Param6):base(Param1, Param2, Param3, Param4, Param5, Param6)
-			{
-			}
-			public override DocIdSet GetDocIdSet(IndexReader reader)
-			{
-				// we transform the floating point numbers to sortable integers
-				// using NumericUtils to easier find the next bigger/lower value
-				float inclusiveLowerPoint;
-				float inclusiveUpperPoint;
-				if (lowerVal != null)
-				{
-					float f = System.Convert.ToSingle(((System.ValueType) lowerVal));
-					if (!includeUpper && f > 0.0f && System.Single.IsInfinity(f))
-						return DocIdSet.EMPTY_DOCIDSET;
-					int i = NumericUtils.FloatToSortableInt(f);
-					inclusiveLowerPoint = NumericUtils.SortableIntToFloat(includeLower?i:(i + 1));
-				}
-				else
-				{
-					inclusiveLowerPoint = System.Single.NegativeInfinity;
-				}
-				if (upperVal != null)
-				{
-					float f = System.Convert.ToSingle(((System.ValueType) upperVal));
-					if (!includeUpper && f < 0.0f && System.Single.IsInfinity(f))
-						return DocIdSet.EMPTY_DOCIDSET;
-					int i = NumericUtils.FloatToSortableInt(f);
-					inclusiveUpperPoint = NumericUtils.SortableIntToFloat(includeUpper?i:(i - 1));
-				}
-				else
-				{
-					inclusiveUpperPoint = System.Single.PositiveInfinity;
-				}
-				
-				if (inclusiveLowerPoint > inclusiveUpperPoint)
-					return DocIdSet.EMPTY_DOCIDSET;
-				
-				float[] values = Lucene.Net.Search.FieldCache_Fields.DEFAULT.GetFloats(reader, field, (Lucene.Net.Search.FloatParser) parser);
-				// we only request the usage of termDocs, if the range contains 0
-				return new AnonymousClassFieldCacheDocIdSet(values, inclusiveLowerPoint, inclusiveUpperPoint, this, reader, (inclusiveLowerPoint <= 0.0f && inclusiveUpperPoint >= 0.0f));
-			}
-		}
-		[Serializable]
-		private class AnonymousClassFieldCacheRangeFilter6:FieldCacheRangeFilter
-		{
-			private class AnonymousClassFieldCacheDocIdSet:FieldCacheDocIdSet
-			{
-				private void  InitBlock(double[] values, double inclusiveLowerPoint, double inclusiveUpperPoint, AnonymousClassFieldCacheRangeFilter6 enclosingInstance)
-				{
-					this.values = values;
-					this.inclusiveLowerPoint = inclusiveLowerPoint;
-					this.inclusiveUpperPoint = inclusiveUpperPoint;
-					this.enclosingInstance = enclosingInstance;
-				}
-				private double[] values;
-				private double inclusiveLowerPoint;
-				private double inclusiveUpperPoint;
-				private AnonymousClassFieldCacheRangeFilter6 enclosingInstance;
-				public AnonymousClassFieldCacheRangeFilter6 Enclosing_Instance
-				{
-					get
-					{
-						return enclosingInstance;
-					}
-					
-				}
-				internal AnonymousClassFieldCacheDocIdSet(double[] values, double inclusiveLowerPoint, double inclusiveUpperPoint, AnonymousClassFieldCacheRangeFilter6 enclosingInstance, Lucene.Net.Index.IndexReader Param1, bool Param2):base(Param1, Param2)
-				{
-					InitBlock(values, inclusiveLowerPoint, inclusiveUpperPoint, enclosingInstance);
-				}
-				internal override bool MatchDoc(int doc)
-				{
-					return values[doc] >= inclusiveLowerPoint && values[doc] <= inclusiveUpperPoint;
-				}
-			}
-			internal AnonymousClassFieldCacheRangeFilter6(System.String Param1, Lucene.Net.Search.Parser Param2, System.Object Param3, System.Object Param4, bool Param5, bool Param6):base(Param1, Param2, Param3, Param4, Param5, Param6)
-			{
-			}
-			public override DocIdSet GetDocIdSet(IndexReader reader)
-			{
-				// we transform the floating point numbers to sortable integers
-				// using NumericUtils to easier find the next bigger/lower value
-				double inclusiveLowerPoint;
-				double inclusiveUpperPoint;
-				if (lowerVal != null)
-				{
-					double f = System.Convert.ToDouble(((System.ValueType) lowerVal));
-					if (!includeUpper && f > 0.0 && System.Double.IsInfinity(f))
-						return DocIdSet.EMPTY_DOCIDSET;
-					long i = NumericUtils.DoubleToSortableLong(f);
-					inclusiveLowerPoint = NumericUtils.SortableLongToDouble(includeLower?i:(i + 1L));
-				}
-				else
-				{
-					inclusiveLowerPoint = System.Double.NegativeInfinity;
-				}
-				if (upperVal != null)
-				{
-					double f = System.Convert.ToDouble(((System.ValueType) upperVal));
-					if (!includeUpper && f < 0.0 && System.Double.IsInfinity(f))
-						return DocIdSet.EMPTY_DOCIDSET;
-					long i = NumericUtils.DoubleToSortableLong(f);
-					inclusiveUpperPoint = NumericUtils.SortableLongToDouble(includeUpper?i:(i - 1L));
-				}
-				else
-				{
-					inclusiveUpperPoint = System.Double.PositiveInfinity;
-				}
-				
-				if (inclusiveLowerPoint > inclusiveUpperPoint)
-					return DocIdSet.EMPTY_DOCIDSET;
-				
-				double[] values = Lucene.Net.Search.FieldCache_Fields.DEFAULT.GetDoubles(reader, field, (Lucene.Net.Search.DoubleParser) parser);
-				// we only request the usage of termDocs, if the range contains 0
-				return new AnonymousClassFieldCacheDocIdSet(values, inclusiveLowerPoint, inclusiveUpperPoint, this, reader, (inclusiveLowerPoint <= 0.0 && inclusiveUpperPoint >= 0.0));
-			}
-		}
 		internal System.String field;
 		internal Lucene.Net.Search.Parser parser;
-		internal System.Object lowerVal;
-		internal System.Object upperVal;
+		internal T lowerVal;
+		internal T upperVal;
 		internal bool includeLower;
 		internal bool includeUpper;
 		
-		private FieldCacheRangeFilter(System.String field, Lucene.Net.Search.Parser parser, System.Object lowerVal, System.Object upperVal, bool includeLower, bool includeUpper)
+		protected internal FieldCacheRangeFilter(System.String field, Lucene.Net.Search.Parser parser, T lowerVal, T upperVal, bool includeLower, bool includeUpper)
 		{
 			this.field = field;
 			this.parser = parser;
@@ -605,123 +739,6 @@ namespace Lucene.Net.Search
 		/// <summary>This method is implemented for each data type </summary>
 		public abstract override DocIdSet GetDocIdSet(IndexReader reader);
 		
-		/// <summary> Creates a string range query using <see cref="FieldCache.GetStringIndex(IndexReader,string)" />. This works with all
-		/// fields containing zero or one term in the field. The range can be half-open by setting one
-		/// of the values to <c>null</c>.
-		/// </summary>
-		public static FieldCacheRangeFilter NewStringRange(System.String field, System.String lowerVal, System.String upperVal, bool includeLower, bool includeUpper)
-		{
-			return new AnonymousClassFieldCacheRangeFilter(field, null, lowerVal, upperVal, includeLower, includeUpper);
-		}
-		
-		/// <summary> Creates a numeric range query using <see cref="FieldCache.GetBytes(IndexReader,String)" />. This works with all
-		/// byte fields containing exactly one numeric term in the field. The range can be half-open by setting one
-		/// of the values to <c>null</c>.
-		/// </summary>
-		public static FieldCacheRangeFilter NewByteRange(System.String field, System.Byte lowerVal, System.Byte upperVal, bool includeLower, bool includeUpper)
-		{
-			return NewByteRange(field, null, lowerVal, upperVal, includeLower, includeUpper);
-		}
-		
-		/// <summary> Creates a numeric range query using <see cref="FieldCache.GetBytes(IndexReader,String,ByteParser)" />. This works with all
-		/// byte fields containing exactly one numeric term in the field. The range can be half-open by setting one
-		/// of the values to <c>null</c>.
-		/// </summary>
-		public static FieldCacheRangeFilter NewByteRange(System.String field, Lucene.Net.Search.ByteParser parser, System.Byte lowerVal, System.Byte upperVal, bool includeLower, bool includeUpper)
-		{
-			return new AnonymousClassFieldCacheRangeFilter1(field, parser, lowerVal, upperVal, includeLower, includeUpper);
-		}
-		
-		/// <summary> Creates a numeric range query using <see cref="FieldCache.GetShorts(IndexReader,String)" />. This works with all
-		/// short fields containing exactly one numeric term in the field. The range can be half-open by setting one
-		/// of the values to <c>null</c>.
-		/// </summary>
-		public static FieldCacheRangeFilter NewShortRange(System.String field, System.ValueType lowerVal, System.ValueType upperVal, bool includeLower, bool includeUpper)
-		{
-			return NewShortRange(field, null, lowerVal, upperVal, includeLower, includeUpper);
-		}
-		
-		/// <summary> Creates a numeric range query using <see cref="FieldCache.GetShorts(IndexReader,String,ShortParser)" />. This works with all
-		/// short fields containing exactly one numeric term in the field. The range can be half-open by setting one
-		/// of the values to <c>null</c>.
-		/// </summary>
-		public static FieldCacheRangeFilter NewShortRange(System.String field, Lucene.Net.Search.ShortParser parser, System.ValueType lowerVal, System.ValueType upperVal, bool includeLower, bool includeUpper)
-		{
-			return new AnonymousClassFieldCacheRangeFilter2(field, parser, lowerVal, upperVal, includeLower, includeUpper);
-		}
-		
-		/// <summary> Creates a numeric range query using <see cref="FieldCache.GetInts(IndexReader,String)" />. This works with all
-		/// int fields containing exactly one numeric term in the field. The range can be half-open by setting one
-		/// of the values to <c>null</c>.
-		/// </summary>
-        public static FieldCacheRangeFilter NewIntRange(System.String field, System.ValueType lowerVal, System.ValueType upperVal, bool includeLower, bool includeUpper)
-		{
-			return NewIntRange(field, null, lowerVal, upperVal, includeLower, includeUpper);
-		}
-		
-		/// <summary> Creates a numeric range query using <see cref="FieldCache.GetInts(IndexReader,String,IntParser)" />. This works with all
-		/// int fields containing exactly one numeric term in the field. The range can be half-open by setting one
-		/// of the values to <c>null</c>.
-		/// </summary>
-		public static FieldCacheRangeFilter NewIntRange(System.String field, Lucene.Net.Search.IntParser parser, System.ValueType lowerVal, System.ValueType upperVal, bool includeLower, bool includeUpper)
-		{
-			return new AnonymousClassFieldCacheRangeFilter3(field, parser, lowerVal, upperVal, includeLower, includeUpper);
-		}
-		
-		/// <summary> Creates a numeric range query using <see cref="FieldCache.GetLongs(IndexReader,String)" />. This works with all
-		/// long fields containing exactly one numeric term in the field. The range can be half-open by setting one
-		/// of the values to <c>null</c>.
-		/// </summary>
-		public static FieldCacheRangeFilter NewLongRange(System.String field, System.ValueType lowerVal, System.ValueType upperVal, bool includeLower, bool includeUpper)
-		{
-			return NewLongRange(field, null, lowerVal, upperVal, includeLower, includeUpper);
-		}
-		
-		/// <summary> Creates a numeric range query using <see cref="FieldCache.GetLongs(IndexReader,String,LongParser)" />. This works with all
-		/// long fields containing exactly one numeric term in the field. The range can be half-open by setting one
-		/// of the values to <c>null</c>.
-		/// </summary>
-		public static FieldCacheRangeFilter NewLongRange(System.String field, Lucene.Net.Search.LongParser parser, System.ValueType lowerVal, System.ValueType upperVal, bool includeLower, bool includeUpper)
-		{
-			return new AnonymousClassFieldCacheRangeFilter4(field, parser, lowerVal, upperVal, includeLower, includeUpper);
-		}
-		
-		/// <summary> Creates a numeric range query using <see cref="FieldCache.GetFloats(IndexReader,String)" />. This works with all
-		/// float fields containing exactly one numeric term in the field. The range can be half-open by setting one
-		/// of the values to <c>null</c>.
-		/// </summary>
-		public static FieldCacheRangeFilter NewFloatRange(System.String field, System.ValueType lowerVal, System.ValueType upperVal, bool includeLower, bool includeUpper)
-		{
-			return NewFloatRange(field, null, lowerVal, upperVal, includeLower, includeUpper);
-		}
-		
-		/// <summary> Creates a numeric range query using <see cref="FieldCache.GetFloats(IndexReader,String,FloatParser)" />. This works with all
-		/// float fields containing exactly one numeric term in the field. The range can be half-open by setting one
-		/// of the values to <c>null</c>.
-		/// </summary>
-		public static FieldCacheRangeFilter NewFloatRange(System.String field, Lucene.Net.Search.FloatParser parser, System.ValueType lowerVal, System.ValueType upperVal, bool includeLower, bool includeUpper)
-		{
-			return new AnonymousClassFieldCacheRangeFilter5(field, parser, lowerVal, upperVal, includeLower, includeUpper);
-		}
-		
-		/// <summary> Creates a numeric range query using <see cref="FieldCache.GetDoubles(IndexReader,String)" />. This works with all
-		/// double fields containing exactly one numeric term in the field. The range can be half-open by setting one
-		/// of the values to <c>null</c>.
-		/// </summary>
-		public static FieldCacheRangeFilter NewDoubleRange(System.String field, System.ValueType lowerVal, System.ValueType upperVal, bool includeLower, bool includeUpper)
-		{
-			return NewDoubleRange(field, null, lowerVal, upperVal, includeLower, includeUpper);
-		}
-		
-		/// <summary> Creates a numeric range query using <see cref="FieldCache.GetDoubles(IndexReader,String,DoubleParser)" />. This works with all
-		/// double fields containing exactly one numeric term in the field. The range can be half-open by setting one
-		/// of the values to <c>null</c>.
-		/// </summary>
-		public static FieldCacheRangeFilter NewDoubleRange(System.String field, Lucene.Net.Search.DoubleParser parser, System.ValueType lowerVal, System.ValueType upperVal, bool includeLower, bool includeUpper)
-		{
-			return new AnonymousClassFieldCacheRangeFilter6(field, parser, lowerVal, upperVal, includeLower, includeUpper);
-		}
-		
 		public override System.String ToString()
 		{
 			System.Text.StringBuilder sb = new System.Text.StringBuilder(field).Append(":");
@@ -732,19 +749,19 @@ namespace Lucene.Net.Search
 		{
 			if (this == o)
 				return true;
-			if (!(o is FieldCacheRangeFilter))
+			if (!(o is FieldCacheRangeFilter<T>))
 				return false;
-			FieldCacheRangeFilter other = (FieldCacheRangeFilter) o;
+			FieldCacheRangeFilter<T> other = (FieldCacheRangeFilter<T>) o;
 			
 			if (!this.field.Equals(other.field) || this.includeLower != other.includeLower || this.includeUpper != other.includeUpper)
 			{
 				return false;
 			}
-			if (this.lowerVal != null?!this.lowerVal.Equals(other.lowerVal):other.lowerVal != null)
+			if (this.lowerVal != null ?! this.lowerVal.Equals(other.lowerVal):other.lowerVal != null)
 				return false;
-			if (this.upperVal != null?!this.upperVal.Equals(other.upperVal):other.upperVal != null)
+			if (this.upperVal != null ?! this.upperVal.Equals(other.upperVal):other.upperVal != null)
 				return false;
-			if (this.parser != null?!this.parser.Equals(other.parser):other.parser != null)
+			if (this.parser != null ?! this.parser.Equals(other.parser):other.parser != null)
 				return false;
 			return true;
 		}
@@ -753,16 +770,43 @@ namespace Lucene.Net.Search
 		{
 			int h = field.GetHashCode();
 			h ^= ((lowerVal != null)?lowerVal.GetHashCode():550356204);
-			h = (h << 1) | (SupportClass.Number.URShift(h, 31)); // rotate to distinguish lower from upper
+			h = (h << 1) | (Number.URShift(h, 31)); // rotate to distinguish lower from upper
 			h ^= ((upperVal != null)?upperVal.GetHashCode():- 1674416163);
 			h ^= ((parser != null)?parser.GetHashCode():- 1572457324);
 			h ^= (includeLower?1549299360:- 365038026) ^ (includeUpper?1721088258:1948649653);
 			return h;
 		}
 		
+        /// <summary>
+        /// Returns the field name for this filter
+        /// </summary>
+        public string GetField { get { return field; } }
+
+        /// <summary>
+        /// Returns <c>true</c> if the lower endpoint is inclusive
+        /// </summary>
+        public bool IncludesLower { get { return includeLower; } }
+
+        /// <summary>
+        /// Returns <c>true</c> if the upper endpoint is inclusive
+        /// </summary>
+        public bool IncludesUpper { get { return includeUpper; } }
+
+        /// <summary>
+        /// Returns the lower value of the range filter
+        /// </summary>
+	    public T LowerValue { get { return lowerVal; } }
+
+        /// <summary>
+        /// Returns the upper value of this range filter
+        /// </summary>
+        public T UpperValue { get { return upperVal; } }
+
+        public Parser Parser { get { return parser; } }
+
 		internal abstract class FieldCacheDocIdSet:DocIdSet
 		{
-			private class AnonymousClassDocIdSetIterator:DocIdSetIterator
+			private class AnonymousClassDocIdSetIterator : DocIdSetIterator
 			{
 				public AnonymousClassDocIdSetIterator(Lucene.Net.Index.TermDocs termDocs, FieldCacheDocIdSet enclosingInstance)
 				{
@@ -785,29 +829,6 @@ namespace Lucene.Net.Search
 				}
 				private int doc = - 1;
 				
-				// @deprecated use <see cref="NextDoc()" /> instead.
-                [Obsolete("Lucene.Net-2.9.1. This method overrides obsolete member Lucene.Net.Search.DocIdSetIterator.Next()")]
-				public override bool Next()
-				{
-					return NextDoc() != NO_MORE_DOCS;
-				}
-				
-				/// <deprecated> use <see cref="Advance(int)" /> instead. 
-				/// </deprecated>
-                [Obsolete("use Advance(int) instead.")]
-				public override bool SkipTo(int target)
-				{
-					return Advance(target) != NO_MORE_DOCS;
-				}
-				
-				/// <deprecated> use <see cref="DocID()" /> instead. 
-				/// </deprecated>
-                [Obsolete("use DocID() instead.")]
-				public override int Doc()
-				{
-					return termDocs.Doc();
-				}
-				
 				public override int DocID()
 				{
 					return doc;
@@ -857,30 +878,6 @@ namespace Lucene.Net.Search
 				}
 				private int doc = - 1;
 				
-				/// <deprecated> use <see cref="NextDoc()" /> instead. 
-				/// </deprecated>
-                [Obsolete("use NextDoc() instead.")]
-				public override bool Next()
-				{
-					return NextDoc() != NO_MORE_DOCS;
-				}
-				
-				/// <deprecated> use <see cref="Advance(int)" /> instead. 
-				/// </deprecated>
-                [Obsolete("use Advance(int) instead.")]
-				public override bool SkipTo(int target)
-				{
-					return Advance(target) != NO_MORE_DOCS;
-				}
-				
-				/// <deprecated> use <see cref="DocID()" /> instead. 
-				/// </deprecated>
-                [Obsolete("use DocID() instead. ")]
-				public override int Doc()
-				{
-					return doc;
-				}
-				
 				public override int DocID()
 				{
 					return doc;

Modified: incubator/lucene.net/trunk/src/core/Search/FieldCacheTermsFilter.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/FieldCacheTermsFilter.cs?rev=1294875&r1=1294874&r2=1294875&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/FieldCacheTermsFilter.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/FieldCacheTermsFilter.cs Tue Feb 28 22:43:08 2012
@@ -99,7 +99,7 @@ namespace Lucene.Net.Search
 		private System.String field;
 		private System.String[] terms;
 		
-		public FieldCacheTermsFilter(System.String field, System.String[] terms)
+		public FieldCacheTermsFilter(System.String field, params System.String[] terms)
 		{
 			this.field = field;
 			this.terms = terms;
@@ -181,27 +181,11 @@ namespace Lucene.Net.Search
 				}
 				private int doc = - 1;
 				
-				/// <deprecated> use <see cref="DocID()" /> instead. 
-				/// </deprecated>
-                [Obsolete("use DocID() instead.")]
-				public override int Doc()
-				{
-					return doc;
-				}
-				
 				public override int DocID()
 				{
 					return doc;
 				}
 				
-				/// <deprecated> use <see cref="NextDoc()" /> instead. 
-				/// </deprecated>
-                [Obsolete("use NextDoc() instead.")]
-				public override bool Next()
-				{
-					return NextDoc() != NO_MORE_DOCS;
-				}
-				
 				public override int NextDoc()
 				{
 					try
@@ -217,14 +201,6 @@ namespace Lucene.Net.Search
 					return doc;
 				}
 				
-				/// <deprecated> use <see cref="Advance(int)" /> instead. 
-				/// </deprecated>
-                [Obsolete("use Advance(int) instead.")]
-				public override bool SkipTo(int target)
-				{
-					return Advance(target) != NO_MORE_DOCS;
-				}
-				
 				public override int Advance(int target)
 				{
 					try

Modified: incubator/lucene.net/trunk/src/core/Search/FieldComparator.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/FieldComparator.cs?rev=1294875&r1=1294874&r2=1294875&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/FieldComparator.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/FieldComparator.cs Tue Feb 28 22:43:08 2012
@@ -16,7 +16,7 @@
  */
 
 using System;
-
+using Lucene.Net.Support;
 using IndexReader = Lucene.Net.Index.IndexReader;
 using ByteParser = Lucene.Net.Search.ByteParser;
 using DoubleParser = Lucene.Net.Search.DoubleParser;
@@ -82,7 +82,94 @@ namespace Lucene.Net.Search
 	/// </summary>
 	public abstract class FieldComparator
 	{
-		
+        /// <summary> Compare hit at slot1 with hit at slot2.
+        /// 
+        /// </summary>
+        /// <param name="slot1">first slot to compare
+        /// </param>
+        /// <param name="slot2">second slot to compare
+        /// </param>
+        /// <returns> any N &lt; 0 if slot2's value is sorted after
+        /// slot1, any N > 0 if the slot2's value is sorted before
+        /// slot1 and 0 if they are equal
+        /// </returns>
+        public abstract int Compare(int slot1, int slot2);
+
+        /// <summary> Set the bottom slot, ie the "weakest" (sorted last)
+        /// entry in the queue.  When <see cref="CompareBottom" /> is
+        /// called, you should compare against this slot.  This
+        /// will always be called before <see cref="CompareBottom" />.
+        /// 
+        /// </summary>
+        /// <param name="slot">the currently weakest (sorted last) slot in the queue
+        /// </param>
+        public abstract void SetBottom(int slot);
+
+        /// <summary> Compare the bottom of the queue with doc.  This will
+        /// only invoked after setBottom has been called.  This
+        /// should return the same result as <see cref="Compare(int,int)" />
+        ///} as if bottom were slot1 and the new
+        /// document were slot 2.
+        /// 
+        /// <p/>For a search that hits many results, this method
+        /// will be the hotspot (invoked by far the most
+        /// frequently).<p/>
+        /// 
+        /// </summary>
+        /// <param name="doc">that was hit
+        /// </param>
+        /// <returns> any N &lt; 0 if the doc's value is sorted after
+        /// the bottom entry (not competitive), any N > 0 if the
+        /// doc's value is sorted before the bottom entry and 0 if
+        /// they are equal.
+        /// </returns>
+        public abstract int CompareBottom(int doc);
+
+        /// <summary> This method is called when a new hit is competitive.
+        /// You should copy any state associated with this document
+        /// that will be required for future comparisons, into the
+        /// specified slot.
+        /// 
+        /// </summary>
+        /// <param name="slot">which slot to copy the hit to
+        /// </param>
+        /// <param name="doc">docID relative to current reader
+        /// </param>
+        public abstract void Copy(int slot, int doc);
+
+        /// <summary> Set a new Reader. All doc correspond to the current Reader.
+        /// 
+        /// </summary>
+        /// <param name="reader">current reader
+        /// </param>
+        /// <param name="docBase">docBase of this reader 
+        /// </param>
+        /// <throws>  IOException </throws>
+        /// <throws>  IOException </throws>
+        public abstract void SetNextReader(IndexReader reader, int docBase);
+
+        /// <summary>Sets the Scorer to use in case a document's score is
+        /// needed.
+        /// 
+        /// </summary>
+        /// <param name="scorer">Scorer instance that you should use to
+        /// obtain the current hit's score, if necessary. 
+        /// </param>
+        public virtual void SetScorer(Scorer scorer)
+        {
+            // Empty implementation since most comparators don't need the score. This
+            // can be overridden by those that need it.
+        }
+
+        /// <summary> Return the actual value in the slot.
+        /// 
+        /// </summary>
+        /// <param name="slot">the value
+        /// </param>
+        /// <returns> value in this slot upgraded to Comparable
+        /// </returns>
+        public abstract System.IComparable Value(int slot);
+
 		/// <summary>Parses field's values as byte (using <see cref="FieldCache.GetBytes(Lucene.Net.Index.IndexReader,string)" />
 		/// and sorts by ascending value 
 		/// </summary>
@@ -953,7 +1040,7 @@ namespace Lucene.Net.Search
 			
 			while (low <= high)
 			{
-				int mid = SupportClass.Number.URShift((low + high), 1);
+				int mid = Number.URShift((low + high), 1);
 				System.String midVal = a[mid];
 				int cmp;
 				if (midVal != null)
@@ -974,93 +1061,5 @@ namespace Lucene.Net.Search
 			}
 			return - (low + 1);
 		}
-		
-		/// <summary> Compare hit at slot1 with hit at slot2.
-		/// 
-		/// </summary>
-		/// <param name="slot1">first slot to compare
-		/// </param>
-		/// <param name="slot2">second slot to compare
-		/// </param>
-        /// <returns> any N &lt; 0 if slot2's value is sorted after
-		/// slot1, any N > 0 if the slot2's value is sorted before
-		/// slot1 and 0 if they are equal
-		/// </returns>
-		public abstract int Compare(int slot1, int slot2);
-		
-		/// <summary> Set the bottom slot, ie the "weakest" (sorted last)
-		/// entry in the queue.  When <see cref="CompareBottom" /> is
-		/// called, you should compare against this slot.  This
-		/// will always be called before <see cref="CompareBottom" />.
-		/// 
-		/// </summary>
-		/// <param name="slot">the currently weakest (sorted last) slot in the queue
-		/// </param>
-		public abstract void  SetBottom(int slot);
-		
-		/// <summary> Compare the bottom of the queue with doc.  This will
-		/// only invoked after setBottom has been called.  This
-		/// should return the same result as <see cref="Compare(int,int)" />
-		///} as if bottom were slot1 and the new
-		/// document were slot 2.
-		/// 
-		/// <p/>For a search that hits many results, this method
-		/// will be the hotspot (invoked by far the most
-		/// frequently).<p/>
-		/// 
-		/// </summary>
-		/// <param name="doc">that was hit
-		/// </param>
-        /// <returns> any N &lt; 0 if the doc's value is sorted after
-		/// the bottom entry (not competitive), any N > 0 if the
-		/// doc's value is sorted before the bottom entry and 0 if
-		/// they are equal.
-		/// </returns>
-		public abstract int CompareBottom(int doc);
-		
-		/// <summary> This method is called when a new hit is competitive.
-		/// You should copy any state associated with this document
-		/// that will be required for future comparisons, into the
-		/// specified slot.
-		/// 
-		/// </summary>
-		/// <param name="slot">which slot to copy the hit to
-		/// </param>
-		/// <param name="doc">docID relative to current reader
-		/// </param>
-		public abstract void  Copy(int slot, int doc);
-		
-		/// <summary> Set a new Reader. All doc correspond to the current Reader.
-		/// 
-		/// </summary>
-		/// <param name="reader">current reader
-		/// </param>
-		/// <param name="docBase">docBase of this reader 
-		/// </param>
-		/// <throws>  IOException </throws>
-		/// <throws>  IOException </throws>
-		public abstract void  SetNextReader(IndexReader reader, int docBase);
-		
-		/// <summary>Sets the Scorer to use in case a document's score is
-		/// needed.
-		/// 
-		/// </summary>
-		/// <param name="scorer">Scorer instance that you should use to
-		/// obtain the current hit's score, if necessary. 
-		/// </param>
-		public virtual void  SetScorer(Scorer scorer)
-		{
-			// Empty implementation since most comparators don't need the score. This
-			// can be overridden by those that need it.
-		}
-		
-		/// <summary> Return the actual value in the slot.
-		/// 
-		/// </summary>
-		/// <param name="slot">the value
-		/// </param>
-		/// <returns> value in this slot upgraded to Comparable
-		/// </returns>
-		public abstract System.IComparable Value(int slot);
 	}
 }
\ No newline at end of file

Modified: incubator/lucene.net/trunk/src/core/Search/FieldDoc.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/FieldDoc.cs?rev=1294875&r1=1294874&r2=1294875&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/FieldDoc.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/FieldDoc.cs Tue Feb 28 22:43:08 2012
@@ -35,14 +35,8 @@ namespace Lucene.Net.Search
 	/// <p/>Created: Feb 11, 2004 1:23:38 PM
 	/// 
 	/// </summary>
-	/// <since>   lucene 1.4
-	/// </since>
-	/// <version>  $Id: FieldDoc.java 773194 2009-05-09 10:36:41Z mikemccand $
-	/// </version>
-	/// <seealso cref="ScoreDoc">
-	/// </seealso>
-	/// <seealso cref="TopFieldDocs">
-	/// </seealso>
+	/// <seealso cref="ScoreDoc"></seealso>
+	/// <seealso cref="TopFieldDocs"></seealso>
 	[Serializable]
 	public class FieldDoc:ScoreDoc
 	{



Mime
View raw message