lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From synhers...@apache.org
Subject [2/3] git commit: Sorting the mess with FieldCache and FieldCache_Fields
Date Fri, 19 Sep 2014 15:05:40 GMT
Sorting the mess with FieldCache and FieldCache_Fields


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

Branch: refs/heads/master
Commit: ddec100aca01518931673476a97468ff465ea5d0
Parents: 433a340
Author: Itamar Syn-Hershko <itamar@code972.com>
Authored: Fri Sep 19 17:56:38 2014 +0300
Committer: Itamar Syn-Hershko <itamar@code972.com>
Committed: Fri Sep 19 17:56:38 2014 +0300

----------------------------------------------------------------------
 .../Document/DoubleDocValuesField.cs            |   2 +-
 src/Lucene.Net.Core/Document/DoubleField.cs     |   2 +-
 .../Document/FloatDocValuesField.cs             |   2 +-
 src/Lucene.Net.Core/Document/FloatField.cs      |   2 +-
 src/Lucene.Net.Core/Document/IntField.cs        |   2 +-
 src/Lucene.Net.Core/Index/FilterAtomicReader.cs |   2 +-
 src/Lucene.Net.Core/Index/SegmentReader.cs      |   4 +-
 .../Search/DocTermOrdsRangeFilter.cs            |   6 +-
 .../Search/DocTermOrdsRewriteMethod.cs          |   2 +-
 src/Lucene.Net.Core/Search/FieldCache.cs        |  57 +++----
 src/Lucene.Net.Core/Search/FieldCacheImpl.cs    | 156 +++++++++----------
 .../Search/FieldCacheRangeFilter.cs             | 106 ++++++-------
 .../Search/FieldCacheRewriteMethod.cs           |   2 +-
 .../Search/FieldCacheTermsFilter.cs             |   4 +-
 src/Lucene.Net.Core/Search/FieldComparator.cs   |  72 ++++-----
 src/Lucene.Net.Core/Search/FieldValueFilter.cs  |   4 +-
 src/Lucene.Net.Core/Search/SortField.cs         |  36 ++---
 .../Util/FieldCacheSanityChecker.cs             |  40 +++--
 .../Index/BaseDocValuesFormatTestCase.cs        |  16 +-
 .../Index/BaseStoredFieldsFormatTestCase.cs     |   4 +-
 .../Search/QueryUtils.cs                        |   2 +-
 .../Util/LuceneTestCase.cs                      |   6 +-
 .../core/Index/TestDirectoryReader.cs           |   6 +-
 .../core/Index/TestDocTermOrds.cs               |  14 +-
 .../core/Index/TestDocValuesIndexing.cs         |  10 +-
 .../core/Index/TestDocValuesWithThreads.cs      |  20 +--
 .../core/Index/TestIndexWriter.cs               |   4 +-
 .../core/Index/TestPostingsOffsets.cs           |   4 +-
 .../core/Index/TestTermsEnum.cs                 |   4 +-
 .../core/Search/JustCompileSearch.cs            |   4 +-
 .../core/Search/TestDocValuesScoring.cs         |   6 +-
 .../core/Search/TestElevationComparator.cs      |   2 +-
 src/Lucene.Net.Tests/core/Search/TestSort.cs    |  12 +-
 .../core/Search/TestSortDocValues.cs            |   4 +-
 .../core/Search/TestSortRandom.cs               |   2 +-
 .../core/Util/TestFieldCacheSanityChecker.cs    |  19 ++-
 36 files changed, 319 insertions(+), 321 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/lucenenet/blob/ddec100a/src/Lucene.Net.Core/Document/DoubleDocValuesField.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Document/DoubleDocValuesField.cs b/src/Lucene.Net.Core/Document/DoubleDocValuesField.cs
index a74f852..598ed04 100644
--- a/src/Lucene.Net.Core/Document/DoubleDocValuesField.cs
+++ b/src/Lucene.Net.Core/Document/DoubleDocValuesField.cs
@@ -29,7 +29,7 @@ namespace Lucene.Net.Documents
     /// via <seealso cref="Double#doubleToRawLongBits(double)"/>.
     /// <p>
     /// Per-document double values can be retrieved via
-    /// <seealso cref="FieldCache#getDoubles(AtomicReader, String, boolean)"/>.
+    /// <seealso cref="IFieldCache#getDoubles(AtomicReader, String, boolean)"/>.
     /// <p>
     /// <b>NOTE</b>: In most all cases this will be rather inefficient,
     /// requiring eight bytes per document. Consider encoding double

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/ddec100a/src/Lucene.Net.Core/Document/DoubleField.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Document/DoubleField.cs b/src/Lucene.Net.Core/Document/DoubleField.cs
index 2fc1826..b8f0a18 100644
--- a/src/Lucene.Net.Core/Document/DoubleField.cs
+++ b/src/Lucene.Net.Core/Document/DoubleField.cs
@@ -59,7 +59,7 @@ namespace Lucene.Net.Documents
     /// NumericRangeFilter}.  To sort according to a
     /// <code>DoubleField</code>, use the normal numeric sort types, eg
     /// <seealso cref="Lucene.Net.Search.SortField.Type#DOUBLE"/>. <code>DoubleField</code>
-    /// values can also be loaded directly from <seealso cref="FieldCache"/>.</p>
+    /// values can also be loaded directly from <seealso cref="IFieldCache"/>.</p>
     ///
     /// <p>You may add the same field name as an <code>DoubleField</code> to
     /// the same document more than once.  Range querying and

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/ddec100a/src/Lucene.Net.Core/Document/FloatDocValuesField.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Document/FloatDocValuesField.cs b/src/Lucene.Net.Core/Document/FloatDocValuesField.cs
index 8e8d7bb..465c715 100644
--- a/src/Lucene.Net.Core/Document/FloatDocValuesField.cs
+++ b/src/Lucene.Net.Core/Document/FloatDocValuesField.cs
@@ -29,7 +29,7 @@ namespace Lucene.Net.Documents
     /// via <seealso cref="Float#floatToRawIntBits(float)"/>.
     /// <p>
     /// Per-document floating point values can be retrieved via
-    /// <seealso cref="FieldCache#getFloats(AtomicReader, String, boolean)"/>.
+    /// <seealso cref="IFieldCache#getFloats(AtomicReader, String, boolean)"/>.
     /// <p>
     /// <b>NOTE</b>: In most all cases this will be rather inefficient,
     /// requiring four bytes per document. Consider encoding floating

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/ddec100a/src/Lucene.Net.Core/Document/FloatField.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Document/FloatField.cs b/src/Lucene.Net.Core/Document/FloatField.cs
index 8e0e64f..8056a9b 100644
--- a/src/Lucene.Net.Core/Document/FloatField.cs
+++ b/src/Lucene.Net.Core/Document/FloatField.cs
@@ -59,7 +59,7 @@ namespace Lucene.Net.Documents
     /// NumericRangeFilter}.  To sort according to a
     /// <code>FloatField</code>, use the normal numeric sort types, eg
     /// <seealso cref="Lucene.Net.Search.SortField.Type#FLOAT"/>. <code>FloatField</code>
-    /// values can also be loaded directly from <seealso cref="FieldCache"/>.</p>
+    /// values can also be loaded directly from <seealso cref="IFieldCache"/>.</p>
     ///
     /// <p>You may add the same field name as an <code>FloatField</code> to
     /// the same document more than once.  Range querying and

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/ddec100a/src/Lucene.Net.Core/Document/IntField.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Document/IntField.cs b/src/Lucene.Net.Core/Document/IntField.cs
index 1a52496..6ad726e 100644
--- a/src/Lucene.Net.Core/Document/IntField.cs
+++ b/src/Lucene.Net.Core/Document/IntField.cs
@@ -58,7 +58,7 @@ namespace Lucene.Net.Documents
     /// NumericRangeFilter}.  To sort according to a
     /// <code>IntField</code>, use the normal numeric sort types, eg
     /// <seealso cref="Lucene.Net.Search.SortField.Type#INT"/>. <code>IntField</code>
-    /// values can also be loaded directly from <seealso cref="FieldCache"/>.</p>
+    /// values can also be loaded directly from <seealso cref="IFieldCache"/>.</p>
     ///
     /// <p>You may add the same field name as an <code>IntField</code> to
     /// the same document more than once.  Range querying and

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/ddec100a/src/Lucene.Net.Core/Index/FilterAtomicReader.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Index/FilterAtomicReader.cs b/src/Lucene.Net.Core/Index/FilterAtomicReader.cs
index f142fb8..2a993c5 100644
--- a/src/Lucene.Net.Core/Index/FilterAtomicReader.cs
+++ b/src/Lucene.Net.Core/Index/FilterAtomicReader.cs
@@ -38,7 +38,7 @@ namespace Lucene.Net.Index
     /// to override <seealso cref="#numDocs()"/> as well and vice-versa.
     /// <p><b>NOTE</b>: If this <seealso cref="FilterAtomicReader"/> does not change the
     /// content the contained reader, you could consider overriding
-    /// <seealso cref="#getCoreCacheKey()"/> so that <seealso cref="FieldCache"/> and
+    /// <seealso cref="#getCoreCacheKey()"/> so that <seealso cref="IFieldCache"/> and
     /// <seealso cref="CachingWrapperFilter"/> share the same entries for this atomic reader
     /// and the wrapped one. <seealso cref="#getCombinedCoreAndDeletesKey()"/> could be
     /// overridden as well if the <seealso cref="#getLiveDocs() live docs"/> are not changed

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/ddec100a/src/Lucene.Net.Core/Index/SegmentReader.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Index/SegmentReader.cs b/src/Lucene.Net.Core/Index/SegmentReader.cs
index 7b417b4..8c4e187 100644
--- a/src/Lucene.Net.Core/Index/SegmentReader.cs
+++ b/src/Lucene.Net.Core/Index/SegmentReader.cs
@@ -2,6 +2,7 @@ using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Globalization;
+using Lucene.Net.Search;
 
 namespace Lucene.Net.Index
 {
@@ -32,7 +33,6 @@ namespace Lucene.Net.Index
     using DocValuesFormat = Lucene.Net.Codecs.DocValuesFormat;
     using DocValuesProducer = Lucene.Net.Codecs.DocValuesProducer;
     using DocValuesType = Lucene.Net.Index.FieldInfo.DocValuesType_e;
-    using FieldCache = Lucene.Net.Search.FieldCache;
     using IOContext = Lucene.Net.Store.IOContext;
     using IOUtils = Lucene.Net.Util.IOUtils;
     using StoredFieldsReader = Lucene.Net.Codecs.StoredFieldsReader;
@@ -668,7 +668,7 @@ namespace Lucene.Net.Index
         /// sharing the same core are closed.  At this point it
         /// is safe for apps to evict this reader from any caches
         /// keyed on <seealso cref="#getCoreCacheKey"/>.  this is the same
-        /// interface that <seealso cref="FieldCache"/> uses, internally,
+        /// interface that <seealso cref="IFieldCache"/> uses, internally,
         /// to evict entries.</p>
         ///
         /// @lucene.experimental

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/ddec100a/src/Lucene.Net.Core/Search/DocTermOrdsRangeFilter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Search/DocTermOrdsRangeFilter.cs b/src/Lucene.Net.Core/Search/DocTermOrdsRangeFilter.cs
index 8da560c..92618a5 100644
--- a/src/Lucene.Net.Core/Search/DocTermOrdsRangeFilter.cs
+++ b/src/Lucene.Net.Core/Search/DocTermOrdsRangeFilter.cs
@@ -29,7 +29,7 @@ namespace Lucene.Net.Search
     using SortedSetDocValues = Lucene.Net.Index.SortedSetDocValues;
 
     /// <summary>
-    /// A range filter built on top of a cached multi-valued term field (in <seealso cref="FieldCache"/>).
+    /// A range filter built on top of a cached multi-valued term field (in <seealso cref="IFieldCache"/>).
     ///
     /// <p>Like <seealso cref="FieldCacheRangeFilter"/>, this is just a specialized range query versus
     ///    using a TermRangeQuery with <seealso cref="DocTermOrdsRewriteMethod"/>: it will only do
@@ -58,7 +58,7 @@ namespace Lucene.Net.Search
         public override abstract DocIdSet GetDocIdSet(AtomicReaderContext context, Bits acceptDocs);
 
         /// <summary>
-        /// Creates a BytesRef range filter using <seealso cref="FieldCache#getTermsIndex"/>. this works with all
+        /// Creates a BytesRef range filter using <seealso cref="IFieldCache#getTermsIndex"/>. 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 <code>null</code>.
         /// </summary>
@@ -87,7 +87,7 @@ namespace Lucene.Net.Search
 
             public override DocIdSet GetDocIdSet(AtomicReaderContext context, Bits acceptDocs)
             {
-                SortedSetDocValues docTermOrds = FieldCache_Fields.DEFAULT.GetDocTermOrds(context.AtomicReader, Field);
+                SortedSetDocValues docTermOrds = FieldCache.DEFAULT.GetDocTermOrds(context.AtomicReader, Field);
                 long lowerPoint = LowerVal == null ? -1 : docTermOrds.LookupTerm(LowerVal);
                 long upperPoint = UpperVal == null ? -1 : docTermOrds.LookupTerm(UpperVal);
 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/ddec100a/src/Lucene.Net.Core/Search/DocTermOrdsRewriteMethod.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Search/DocTermOrdsRewriteMethod.cs b/src/Lucene.Net.Core/Search/DocTermOrdsRewriteMethod.cs
index 28fae0f..99f25c2 100644
--- a/src/Lucene.Net.Core/Search/DocTermOrdsRewriteMethod.cs
+++ b/src/Lucene.Net.Core/Search/DocTermOrdsRewriteMethod.cs
@@ -102,7 +102,7 @@ namespace Lucene.Net.Search
             /// </summary>
             public override DocIdSet GetDocIdSet(AtomicReaderContext context, Bits acceptDocs)
             {
-                SortedSetDocValues docTermOrds = FieldCache_Fields.DEFAULT.GetDocTermOrds((context.AtomicReader), Query.field);
+                SortedSetDocValues docTermOrds = FieldCache.DEFAULT.GetDocTermOrds((context.AtomicReader), Query.field);
                 // Cannot use FixedBitSet because we require long index (ord):
                 LongBitSet termSet = new LongBitSet(docTermOrds.ValueCount);
                 TermsEnum termsEnum = Query.GetTermsEnum(new TermsAnonymousInnerClassHelper(this, docTermOrds));

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/ddec100a/src/Lucene.Net.Core/Search/FieldCache.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Search/FieldCache.cs b/src/Lucene.Net.Core/Search/FieldCache.cs
index 187e0c7..5626f0e 100644
--- a/src/Lucene.Net.Core/Search/FieldCache.cs
+++ b/src/Lucene.Net.Core/Search/FieldCache.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Text;
 using Lucene.Net.Documents;
+using Lucene.Net.Index;
 
 namespace Lucene.Net.Search
 {
@@ -50,7 +51,7 @@ namespace Lucene.Net.Search
     ///
     /// @since   lucene 1.4 </summary>
     /// <seealso cref=Lucene.Net.Util.FieldCacheSanityChecker</seealso>
-    public interface FieldCache
+    public interface IFieldCache
     {
         /// <summary>
         /// Checks the internal cache for an appropriate entry, and if none is found,
@@ -72,7 +73,7 @@ namespace Lucene.Net.Search
         /// <returns> The values in the given field for each document. </returns>
         /// <exception cref="IOException">  If any error occurs. </exception>
         /// @deprecated (4.4) Index as a numeric field using <seealso cref="IntField"/> and then use <seealso cref="#getInts(AtomicReader, String, boolean)"/> instead.
-        FieldCache_Fields.Bytes GetBytes(AtomicReader reader, string field, bool setDocsWithField);
+        FieldCache.Bytes GetBytes(AtomicReader reader, string field, bool setDocsWithField);
 
         /// <summary>
         /// Checks the internal cache for an appropriate entry, and if none is found,
@@ -87,7 +88,7 @@ namespace Lucene.Net.Search
         /// <returns> The values in the given field for each document. </returns>
         /// <exception cref="IOException">  If any error occurs. </exception>
         /// @deprecated (4.4) Index as a numeric field using <seealso cref="IntField"/> and then use <seealso cref="#getInts(AtomicReader, String, boolean)"/> instead.
-        FieldCache_Fields.Bytes GetBytes(AtomicReader reader, string field, FieldCache_Fields.IByteParser parser, bool setDocsWithField);
+        FieldCache.Bytes GetBytes(AtomicReader reader, string field, FieldCache.IByteParser parser, bool setDocsWithField);
 
         /// <summary>
         /// Checks the internal cache for an appropriate entry, and if none is
@@ -101,7 +102,7 @@ namespace Lucene.Net.Search
         /// <returns> The values in the given field for each document. </returns>
         /// <exception cref="IOException">  If any error occurs. </exception>
         /// @deprecated (4.4) Index as a numeric field using <seealso cref="IntField"/> and then use <seealso cref="#getInts(AtomicReader, String, boolean)"/> instead.
-        FieldCache_Fields.Shorts GetShorts(AtomicReader reader, string field, bool setDocsWithField);
+        FieldCache.Shorts GetShorts(AtomicReader reader, string field, bool setDocsWithField);
 
         /// <summary>
         /// Checks the internal cache for an appropriate entry, and if none is found,
@@ -116,17 +117,17 @@ namespace Lucene.Net.Search
         /// <returns> The values in the given field for each document. </returns>
         /// <exception cref="IOException">  If any error occurs. </exception>
         /// @deprecated (4.4) Index as a numeric field using <seealso cref="IntField"/> and then use <seealso cref="#getInts(AtomicReader, String, boolean)"/> instead.
-        FieldCache_Fields.Shorts GetShorts(AtomicReader reader, string field, FieldCache_Fields.IShortParser parser, bool setDocsWithField);
+        FieldCache.Shorts GetShorts(AtomicReader reader, string field, FieldCache.IShortParser parser, bool setDocsWithField);
 
         /// <summary>
-        /// Returns an <seealso cref="FieldCache_Fields.Ints"/> over the values found in documents in the given
+        /// Returns an <seealso cref="FieldCache.Ints"/> over the values found in documents in the given
         /// field.
         /// </summary>
         /// <seealso cref= #getInts(AtomicReader, String, IntParser, boolean) </seealso>
-        FieldCache_Fields.Ints GetInts(AtomicReader reader, string field, bool setDocsWithField);
+        FieldCache.Ints GetInts(AtomicReader reader, string field, bool setDocsWithField);
 
         /// <summary>
-        /// Returns an <seealso cref="Ints"/> over the values found in documents in the given
+        /// Returns an <seealso cref="FieldCache.Ints"/> over the values found in documents in the given
         /// field. If the field was indexed as <seealso cref="NumericDocValuesField"/>, it simply
         /// uses <seealso cref="AtomicReader#getNumericDocValues(String)"/> to read the values.
         /// Otherwise, it checks the internal cache for an appropriate entry, and if
@@ -148,14 +149,14 @@ namespace Lucene.Net.Search
         /// <returns> The values in the given field for each document. </returns>
         /// <exception cref="IOException">
         ///           If any error occurs. </exception>
-        FieldCache_Fields.Ints GetInts(AtomicReader reader, string field, FieldCache_Fields.IIntParser parser, bool setDocsWithField);
+        FieldCache.Ints GetInts(AtomicReader reader, string field, FieldCache.IIntParser parser, bool setDocsWithField);
 
         /// <summary>
         /// Returns a <seealso cref="Floats"/> over the values found in documents in the given
         /// field.
         /// </summary>
         /// <seealso cref= #getFloats(AtomicReader, String, FloatParser, boolean) </seealso>
-        FieldCache_Fields.Floats GetFloats(AtomicReader reader, string field, bool setDocsWithField);
+        FieldCache.Floats GetFloats(AtomicReader reader, string field, bool setDocsWithField);
 
         /// <summary>
         /// Returns a <seealso cref="Floats"/> over the values found in documents in the given
@@ -180,14 +181,14 @@ namespace Lucene.Net.Search
         /// <returns> The values in the given field for each document. </returns>
         /// <exception cref="IOException">
         ///           If any error occurs. </exception>
-        FieldCache_Fields.Floats GetFloats(AtomicReader reader, string field, FieldCache_Fields.IFloatParser parser, bool setDocsWithField);
+        FieldCache.Floats GetFloats(AtomicReader reader, string field, FieldCache.IFloatParser parser, bool setDocsWithField);
 
         /// <summary>
         /// Returns a <seealso cref="Longs"/> over the values found in documents in the given
         /// field.
         /// </summary>
         /// <seealso cref= #getLongs(AtomicReader, String, LongParser, boolean) </seealso>
-        FieldCache_Fields.Longs GetLongs(AtomicReader reader, string field, bool setDocsWithField);
+        FieldCache.Longs GetLongs(AtomicReader reader, string field, bool setDocsWithField);
 
         /// <summary>
         /// Returns a <seealso cref="Longs"/> over the values found in documents in the given
@@ -212,14 +213,14 @@ namespace Lucene.Net.Search
         /// <returns> The values in the given field for each document. </returns>
         /// <exception cref="IOException">
         ///           If any error occurs. </exception>
-        FieldCache_Fields.Longs GetLongs(AtomicReader reader, string field, FieldCache_Fields.ILongParser parser, bool setDocsWithField);
+        FieldCache.Longs GetLongs(AtomicReader reader, string field, FieldCache.ILongParser parser, bool setDocsWithField);
 
         /// <summary>
         /// Returns a <seealso cref="Doubles"/> over the values found in documents in the given
         /// field.
         /// </summary>
         /// <seealso cref= #getDoubles(AtomicReader, String, DoubleParser, boolean) </seealso>
-        FieldCache_Fields.Doubles GetDoubles(AtomicReader reader, string field, bool setDocsWithField);
+        FieldCache.Doubles GetDoubles(AtomicReader reader, string field, bool setDocsWithField);
 
         /// <summary>
         /// Returns a <seealso cref="Doubles"/> over the values found in documents in the given
@@ -244,7 +245,7 @@ namespace Lucene.Net.Search
         /// <returns> The values in the given field for each document. </returns>
         /// <exception cref="IOException">
         ///           If any error occurs. </exception>
-        FieldCache_Fields.Doubles GetDoubles(AtomicReader reader, string field, FieldCache_Fields.IDoubleParser parser, bool setDocsWithField);
+        FieldCache.Doubles GetDoubles(AtomicReader reader, string field, FieldCache.IDoubleParser parser, bool setDocsWithField);
 
         /// <summary>
         /// Checks the internal cache for an appropriate entry, and if none
@@ -318,7 +319,7 @@ namespace Lucene.Net.Search
         /// </p>
         /// @lucene.experimental
         /// </summary>
-        FieldCache_Fields.CacheEntry[] CacheEntries { get; }
+        FieldCache.CacheEntry[] CacheEntries { get; }
 
         /// <summary>
         /// <p>
@@ -351,7 +352,7 @@ namespace Lucene.Net.Search
         StreamWriter InfoStream { set; get; }
     }
 
-    public static class FieldCache_Fields
+    public static class FieldCache
     {
         public abstract class Bytes
         {
@@ -483,7 +484,7 @@ namespace Lucene.Net.Search
             double ParseDouble(BytesRef term);
         }
 
-        public static FieldCache DEFAULT = new FieldCacheImpl();
+        public static IFieldCache DEFAULT = new FieldCacheImpl();
 
         public static readonly IByteParser DEFAULT_BYTE_PARSER = new AnonymousByteParser();
 
@@ -500,7 +501,7 @@ namespace Lucene.Net.Search
 
             public override string ToString()
             {
-                return typeof(FieldCache).FullName + ".DEFAULT_BYTE_PARSER";
+                return typeof(IFieldCache).FullName + ".DEFAULT_BYTE_PARSER";
             }
 
             public TermsEnum TermsEnum(Terms terms)
@@ -524,7 +525,7 @@ namespace Lucene.Net.Search
 
             public override string ToString()
             {
-                return typeof(FieldCache).FullName + ".DEFAULT_SHORT_PARSER";
+                return typeof(IFieldCache).FullName + ".DEFAULT_SHORT_PARSER";
             }
 
             public TermsEnum TermsEnum(Terms terms)
@@ -553,7 +554,7 @@ namespace Lucene.Net.Search
 
             public override string ToString()
             {
-                return typeof(FieldCache).FullName + ".DEFAULT_INT_PARSER";
+                return typeof(IFieldCache).FullName + ".DEFAULT_INT_PARSER";
             }
         }
 
@@ -577,7 +578,7 @@ namespace Lucene.Net.Search
 
             public override string ToString()
             {
-                return typeof(FieldCache).FullName + ".DEFAULT_FLOAT_PARSER";
+                return typeof(IFieldCache).FullName + ".DEFAULT_FLOAT_PARSER";
             }
         }
 
@@ -601,7 +602,7 @@ namespace Lucene.Net.Search
 
             public override string ToString()
             {
-                return typeof(FieldCache).FullName + ".DEFAULT_LONG_PARSER";
+                return typeof(IFieldCache).FullName + ".DEFAULT_LONG_PARSER";
             }
         }
 
@@ -625,7 +626,7 @@ namespace Lucene.Net.Search
 
             public override string ToString()
             {
-                return typeof(FieldCache).FullName + ".DEFAULT_DOUBLE_PARSER";
+                return typeof(IFieldCache).FullName + ".DEFAULT_DOUBLE_PARSER";
             }
         }
 
@@ -645,7 +646,7 @@ namespace Lucene.Net.Search
 
             public override string ToString()
             {
-                return typeof(FieldCache).FullName + ".NUMERIC_UTILS_INT_PARSER";
+                return typeof(IFieldCache).FullName + ".NUMERIC_UTILS_INT_PARSER";
             }
         }
 
@@ -660,7 +661,7 @@ namespace Lucene.Net.Search
 
             public override string ToString()
             {
-                return typeof(FieldCache).FullName + ".NUMERIC_UTILS_FLOAT_PARSER";
+                return typeof(IFieldCache).FullName + ".NUMERIC_UTILS_FLOAT_PARSER";
             }
 
             public TermsEnum TermsEnum(Terms terms)
@@ -680,7 +681,7 @@ namespace Lucene.Net.Search
 
             public override string ToString()
             {
-                return typeof(FieldCache).FullName + ".NUMERIC_UTILS_LONG_PARSER";
+                return typeof(IFieldCache).FullName + ".NUMERIC_UTILS_LONG_PARSER";
             }
 
             public TermsEnum TermsEnum(Terms terms)
@@ -700,7 +701,7 @@ namespace Lucene.Net.Search
 
             public override string ToString()
             {
-                return typeof(FieldCache).FullName + ".NUMERIC_UTILS_DOUBLE_PARSER";
+                return typeof(IFieldCache).FullName + ".NUMERIC_UTILS_DOUBLE_PARSER";
             }
 
             public TermsEnum TermsEnum(Terms terms)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/ddec100a/src/Lucene.Net.Core/Search/FieldCacheImpl.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Search/FieldCacheImpl.cs b/src/Lucene.Net.Core/Search/FieldCacheImpl.cs
index c191344..2434835 100644
--- a/src/Lucene.Net.Core/Search/FieldCacheImpl.cs
+++ b/src/Lucene.Net.Core/Search/FieldCacheImpl.cs
@@ -53,7 +53,7 @@ namespace Lucene.Net.Search
     ///
     /// @since   lucene 1.4
     /// </summary>
-    internal class FieldCacheImpl : FieldCache
+    internal class FieldCacheImpl : IFieldCache
     {
         private IDictionary<Type, Cache> Caches;
 
@@ -103,13 +103,13 @@ namespace Lucene.Net.Search
             }
         }
 
-        public virtual FieldCache_Fields.CacheEntry[] CacheEntries
+        public virtual FieldCache.CacheEntry[] CacheEntries
         {
             get
             {
                 lock (this)
                 {
-                    IList<FieldCache_Fields.CacheEntry> result = new List<FieldCache_Fields.CacheEntry>(17);
+                    IList<FieldCache.CacheEntry> result = new List<FieldCache.CacheEntry>(17);
                     foreach (KeyValuePair<Type, Cache> cacheEntry in Caches)
                     {
                         Cache cache = cacheEntry.Value;
@@ -127,7 +127,7 @@ namespace Lucene.Net.Search
                                 foreach (KeyValuePair<CacheKey, object> mapEntry in innerCache)
                                 {
                                     CacheKey entry = mapEntry.Key;
-                                    result.Add(new FieldCache_Fields.CacheEntry(readerKey, entry.Field, cacheType, entry.Custom, mapEntry.Value));
+                                    result.Add(new FieldCache.CacheEntry(readerKey, entry.Field, cacheType, entry.Custom, mapEntry.Value));
                                 }
                             }
                         }
@@ -273,15 +273,15 @@ namespace Lucene.Net.Search
                     }
                     if (value == null)
                     {
-                        value = new FieldCache_Fields.CreationPlaceholder();
+                        value = new FieldCache.CreationPlaceholder();
                         innerCache[key] = value;
                     }
                 }
-                if (value is FieldCache_Fields.CreationPlaceholder)
+                if (value is FieldCache.CreationPlaceholder)
                 {
                     lock (value)
                     {
-                        FieldCache_Fields.CreationPlaceholder progress = (FieldCache_Fields.CreationPlaceholder)value;
+                        FieldCache.CreationPlaceholder progress = (FieldCache.CreationPlaceholder)value;
                         if (progress.Value == null)
                         {
                             progress.Value = CreateValue(reader, key, setDocsWithField);
@@ -314,7 +314,7 @@ namespace Lucene.Net.Search
                 for (int i = 0; i < insanities.Length; i++)
                 {
                     FieldCacheSanityChecker.Insanity insanity = insanities[i];
-                    FieldCache_Fields.CacheEntry[] entries = insanity.CacheEntries;
+                    FieldCache.CacheEntry[] entries = insanity.CacheEntries;
                     for (int j = 0; j < entries.Length; j++)
                     {
                         if (entries[j].Value == value)
@@ -473,12 +473,12 @@ namespace Lucene.Net.Search
         }
 
         // inherit javadocs
-        public virtual FieldCache_Fields.Bytes GetBytes(AtomicReader reader, string field, bool setDocsWithField)
+        public virtual FieldCache.Bytes GetBytes(AtomicReader reader, string field, bool setDocsWithField)
         {
             return GetBytes(reader, field, null, setDocsWithField);
         }
 
-        public virtual FieldCache_Fields.Bytes GetBytes(AtomicReader reader, string field, FieldCache_Fields.IByteParser parser, bool setDocsWithField)
+        public virtual FieldCache.Bytes GetBytes(AtomicReader reader, string field, FieldCache.IByteParser parser, bool setDocsWithField)
         {
             NumericDocValues valuesIn = reader.GetNumericDocValues(field);
             if (valuesIn != null)
@@ -492,7 +492,7 @@ namespace Lucene.Net.Search
                 FieldInfo info = reader.FieldInfos.FieldInfo(field);
                 if (info == null)
                 {
-                    return FieldCache_Fields.Bytes.EMPTY;
+                    return FieldCache.Bytes.EMPTY;
                 }
                 else if (info.HasDocValues())
                 {
@@ -500,13 +500,13 @@ namespace Lucene.Net.Search
                 }
                 else if (!info.Indexed)
                 {
-                    return FieldCache_Fields.Bytes.EMPTY;
+                    return FieldCache.Bytes.EMPTY;
                 }
-                return (FieldCache_Fields.Bytes)Caches[typeof(sbyte)].Get(reader, new CacheKey(field, parser), setDocsWithField);
+                return (FieldCache.Bytes)Caches[typeof(sbyte)].Get(reader, new CacheKey(field, parser), setDocsWithField);
             }
         }
 
-        private class FieldCache_BytesAnonymousInnerClassHelper : FieldCache_Fields.Bytes
+        private class FieldCache_BytesAnonymousInnerClassHelper : FieldCache.Bytes
         {
             private readonly FieldCacheImpl OuterInstance;
 
@@ -524,7 +524,7 @@ namespace Lucene.Net.Search
             }
         }
 
-        internal class BytesFromArray : FieldCache_Fields.Bytes
+        internal class BytesFromArray : FieldCache.Bytes
         {
             internal readonly sbyte[] Values;
 
@@ -550,13 +550,13 @@ namespace Lucene.Net.Search
             {
                 int maxDoc = reader.MaxDoc;
                 sbyte[] values;
-                FieldCache_Fields.IByteParser parser = (FieldCache_Fields.IByteParser)key.Custom;
+                FieldCache.IByteParser parser = (FieldCache.IByteParser)key.Custom;
                 if (parser == null)
                 {
                     // Confusing: must delegate to wrapper (vs simply
                     // setting parser = DEFAULT_SHORT_PARSER) so cache
                     // key includes DEFAULT_SHORT_PARSER:
-                    return Wrapper.GetBytes(reader, key.Field, FieldCache_Fields.DEFAULT_BYTE_PARSER, setDocsWithField);
+                    return Wrapper.GetBytes(reader, key.Field, FieldCache.DEFAULT_BYTE_PARSER, setDocsWithField);
                 }
 
                 values = new sbyte[maxDoc];
@@ -578,9 +578,9 @@ namespace Lucene.Net.Search
                 private readonly ByteCache OuterInstance;
 
                 private sbyte[] Values;
-                private FieldCache_Fields.IByteParser Parser;
+                private FieldCache.IByteParser Parser;
 
-                public UninvertAnonymousInnerClassHelper(ByteCache outerInstance, sbyte[] values, FieldCache_Fields.IByteParser parser)
+                public UninvertAnonymousInnerClassHelper(ByteCache outerInstance, sbyte[] values, FieldCache.IByteParser parser)
                 {
                     this.OuterInstance = outerInstance;
                     this.Values = values;
@@ -607,13 +607,13 @@ namespace Lucene.Net.Search
         }
 
         // inherit javadocs
-        public virtual FieldCache_Fields.Shorts GetShorts(AtomicReader reader, string field, bool setDocsWithField)
+        public virtual FieldCache.Shorts GetShorts(AtomicReader reader, string field, bool setDocsWithField)
         {
             return GetShorts(reader, field, null, setDocsWithField);
         }
 
         // inherit javadocs
-        public virtual FieldCache_Fields.Shorts GetShorts(AtomicReader reader, string field, FieldCache_Fields.IShortParser parser, bool setDocsWithField)
+        public virtual FieldCache.Shorts GetShorts(AtomicReader reader, string field, FieldCache.IShortParser parser, bool setDocsWithField)
         {
             NumericDocValues valuesIn = reader.GetNumericDocValues(field);
             if (valuesIn != null)
@@ -627,7 +627,7 @@ namespace Lucene.Net.Search
                 FieldInfo info = reader.FieldInfos.FieldInfo(field);
                 if (info == null)
                 {
-                    return FieldCache_Fields.Shorts.EMPTY;
+                    return FieldCache.Shorts.EMPTY;
                 }
                 else if (info.HasDocValues())
                 {
@@ -635,13 +635,13 @@ namespace Lucene.Net.Search
                 }
                 else if (!info.Indexed)
                 {
-                    return FieldCache_Fields.Shorts.EMPTY;
+                    return FieldCache.Shorts.EMPTY;
                 }
-                return (FieldCache_Fields.Shorts)Caches[typeof(short)].Get(reader, new CacheKey(field, parser), setDocsWithField);
+                return (FieldCache.Shorts)Caches[typeof(short)].Get(reader, new CacheKey(field, parser), setDocsWithField);
             }
         }
 
-        private class FieldCache_ShortsAnonymousInnerClassHelper : FieldCache_Fields.Shorts
+        private class FieldCache_ShortsAnonymousInnerClassHelper : FieldCache.Shorts
         {
             private readonly FieldCacheImpl OuterInstance;
 
@@ -659,7 +659,7 @@ namespace Lucene.Net.Search
             }
         }
 
-        internal class ShortsFromArray : FieldCache_Fields.Shorts
+        internal class ShortsFromArray : FieldCache.Shorts
         {
             internal readonly short[] Values;
 
@@ -685,13 +685,13 @@ namespace Lucene.Net.Search
             {
                 int maxDoc = reader.MaxDoc;
                 short[] values;
-                FieldCache_Fields.IShortParser parser = (FieldCache_Fields.IShortParser)key.Custom;
+                FieldCache.IShortParser parser = (FieldCache.IShortParser)key.Custom;
                 if (parser == null)
                 {
                     // Confusing: must delegate to wrapper (vs simply
                     // setting parser = DEFAULT_SHORT_PARSER) so cache
                     // key includes DEFAULT_SHORT_PARSER:
-                    return Wrapper.GetShorts(reader, key.Field, FieldCache_Fields.DEFAULT_SHORT_PARSER, setDocsWithField);
+                    return Wrapper.GetShorts(reader, key.Field, FieldCache.DEFAULT_SHORT_PARSER, setDocsWithField);
                 }
 
                 values = new short[maxDoc];
@@ -711,9 +711,9 @@ namespace Lucene.Net.Search
                 private readonly ShortCache OuterInstance;
 
                 private short[] Values;
-                private FieldCache_Fields.IShortParser Parser;
+                private FieldCache.IShortParser Parser;
 
-                public UninvertAnonymousInnerClassHelper(ShortCache outerInstance, short[] values, FieldCache_Fields.IShortParser parser)
+                public UninvertAnonymousInnerClassHelper(ShortCache outerInstance, short[] values, FieldCache.IShortParser parser)
                 {
                     this.OuterInstance = outerInstance;
                     this.Values = values;
@@ -740,12 +740,12 @@ namespace Lucene.Net.Search
         }
 
         // inherit javadocs
-        public virtual FieldCache_Fields.Ints GetInts(AtomicReader reader, string field, bool setDocsWithField)
+        public virtual FieldCache.Ints GetInts(AtomicReader reader, string field, bool setDocsWithField)
         {
             return GetInts(reader, field, null, setDocsWithField);
         }
 
-        public virtual FieldCache_Fields.Ints GetInts(AtomicReader reader, string field, FieldCache_Fields.IIntParser parser, bool setDocsWithField)
+        public virtual FieldCache.Ints GetInts(AtomicReader reader, string field, FieldCache.IIntParser parser, bool setDocsWithField)
         {
             NumericDocValues valuesIn = reader.GetNumericDocValues(field);
             if (valuesIn != null)
@@ -759,7 +759,7 @@ namespace Lucene.Net.Search
                 FieldInfo info = reader.FieldInfos.FieldInfo(field);
                 if (info == null)
                 {
-                    return FieldCache_Fields.Ints.EMPTY;
+                    return FieldCache.Ints.EMPTY;
                 }
                 else if (info.HasDocValues())
                 {
@@ -767,13 +767,13 @@ namespace Lucene.Net.Search
                 }
                 else if (!info.Indexed)
                 {
-                    return FieldCache_Fields.Ints.EMPTY;
+                    return FieldCache.Ints.EMPTY;
                 }
-                return (FieldCache_Fields.Ints)Caches[typeof(int)].Get(reader, new CacheKey(field, parser), setDocsWithField);
+                return (FieldCache.Ints)Caches[typeof(int)].Get(reader, new CacheKey(field, parser), setDocsWithField);
             }
         }
 
-        private class FieldCache_IntsAnonymousInnerClassHelper : FieldCache_Fields.Ints
+        private class FieldCache_IntsAnonymousInnerClassHelper : FieldCache.Ints
         {
             private readonly FieldCacheImpl OuterInstance;
 
@@ -791,7 +791,7 @@ namespace Lucene.Net.Search
             }
         }
 
-        internal class IntsFromArray : FieldCache_Fields.Ints
+        internal class IntsFromArray : FieldCache.Ints
         {
             internal readonly PackedInts.Reader Values;
             internal readonly int MinValue;
@@ -846,7 +846,7 @@ namespace Lucene.Net.Search
 
             protected internal override object CreateValue(AtomicReader reader, CacheKey key, bool setDocsWithField)
             {
-                FieldCache_Fields.IIntParser parser = (FieldCache_Fields.IIntParser)key.Custom;
+                FieldCache.IIntParser parser = (FieldCache.IIntParser)key.Custom;
                 if (parser == null)
                 {
                     // Confusing: must delegate to wrapper (vs simply
@@ -856,11 +856,11 @@ namespace Lucene.Net.Search
                     // DEFAULT_INT_PARSER/NUMERIC_UTILS_INT_PARSER:
                     try
                     {
-                        return Wrapper.GetInts(reader, key.Field, FieldCache_Fields.DEFAULT_INT_PARSER, setDocsWithField);
+                        return Wrapper.GetInts(reader, key.Field, FieldCache.DEFAULT_INT_PARSER, setDocsWithField);
                     }
                     catch (System.FormatException)
                     {
-                        return Wrapper.GetInts(reader, key.Field, FieldCache_Fields.NUMERIC_UTILS_INT_PARSER, setDocsWithField);
+                        return Wrapper.GetInts(reader, key.Field, FieldCache.NUMERIC_UTILS_INT_PARSER, setDocsWithField);
                     }
                 }
 
@@ -887,10 +887,10 @@ namespace Lucene.Net.Search
                 private readonly IntCache OuterInstance;
 
                 private AtomicReader Reader;
-                private FieldCache_Fields.IIntParser Parser;
+                private FieldCache.IIntParser Parser;
                 private FieldCacheImpl.HoldsOneThing<GrowableWriterAndMinValue> ValuesRef;
 
-                public UninvertAnonymousInnerClassHelper(IntCache outerInstance, AtomicReader reader, FieldCache_Fields.IIntParser parser, FieldCacheImpl.HoldsOneThing<GrowableWriterAndMinValue> valuesRef)
+                public UninvertAnonymousInnerClassHelper(IntCache outerInstance, AtomicReader reader, FieldCache.IIntParser parser, FieldCacheImpl.HoldsOneThing<GrowableWriterAndMinValue> valuesRef)
                 {
                     this.OuterInstance = outerInstance;
                     this.Reader = reader;
@@ -1030,12 +1030,12 @@ namespace Lucene.Net.Search
             }
         }
 
-        public virtual FieldCache_Fields.Floats GetFloats(AtomicReader reader, string field, bool setDocsWithField)
+        public virtual FieldCache.Floats GetFloats(AtomicReader reader, string field, bool setDocsWithField)
         {
             return GetFloats(reader, field, null, setDocsWithField);
         }
 
-        public virtual FieldCache_Fields.Floats GetFloats(AtomicReader reader, string field, FieldCache_Fields.IFloatParser parser, bool setDocsWithField)
+        public virtual FieldCache.Floats GetFloats(AtomicReader reader, string field, FieldCache.IFloatParser parser, bool setDocsWithField)
         {
             NumericDocValues valuesIn = reader.GetNumericDocValues(field);
             if (valuesIn != null)
@@ -1049,7 +1049,7 @@ namespace Lucene.Net.Search
                 FieldInfo info = reader.FieldInfos.FieldInfo(field);
                 if (info == null)
                 {
-                    return FieldCache_Fields.Floats.EMPTY;
+                    return FieldCache.Floats.EMPTY;
                 }
                 else if (info.HasDocValues())
                 {
@@ -1057,13 +1057,13 @@ namespace Lucene.Net.Search
                 }
                 else if (!info.Indexed)
                 {
-                    return FieldCache_Fields.Floats.EMPTY;
+                    return FieldCache.Floats.EMPTY;
                 }
-                return (FieldCache_Fields.Floats)Caches[typeof(float)].Get(reader, new CacheKey(field, parser), setDocsWithField);
+                return (FieldCache.Floats)Caches[typeof(float)].Get(reader, new CacheKey(field, parser), setDocsWithField);
             }
         }
 
-        private class FieldCache_FloatsAnonymousInnerClassHelper : FieldCache_Fields.Floats
+        private class FieldCache_FloatsAnonymousInnerClassHelper : FieldCache.Floats
         {
             private readonly FieldCacheImpl OuterInstance;
 
@@ -1081,7 +1081,7 @@ namespace Lucene.Net.Search
             }
         }
 
-        internal class FloatsFromArray : FieldCache_Fields.Floats
+        internal class FloatsFromArray : FieldCache.Floats
         {
             internal readonly float[] Values;
 
@@ -1105,7 +1105,7 @@ namespace Lucene.Net.Search
 
             protected internal override object CreateValue(AtomicReader reader, CacheKey key, bool setDocsWithField)
             {
-                FieldCache_Fields.IFloatParser parser = (FieldCache_Fields.IFloatParser)key.Custom;
+                FieldCache.IFloatParser parser = (FieldCache.IFloatParser)key.Custom;
                 if (parser == null)
                 {
                     // Confusing: must delegate to wrapper (vs simply
@@ -1115,11 +1115,11 @@ namespace Lucene.Net.Search
                     // DEFAULT_FLOAT_PARSER/NUMERIC_UTILS_FLOAT_PARSER:
                     try
                     {
-                        return Wrapper.GetFloats(reader, key.Field, FieldCache_Fields.DEFAULT_FLOAT_PARSER, setDocsWithField);
+                        return Wrapper.GetFloats(reader, key.Field, FieldCache.DEFAULT_FLOAT_PARSER, setDocsWithField);
                     }
                     catch (System.FormatException)
                     {
-                        return Wrapper.GetFloats(reader, key.Field, FieldCache_Fields.NUMERIC_UTILS_FLOAT_PARSER, setDocsWithField);
+                        return Wrapper.GetFloats(reader, key.Field, FieldCache.NUMERIC_UTILS_FLOAT_PARSER, setDocsWithField);
                     }
                 }
 
@@ -1147,10 +1147,10 @@ namespace Lucene.Net.Search
                 private readonly FloatCache OuterInstance;
 
                 private AtomicReader Reader;
-                private FieldCache_Fields.IFloatParser Parser;
+                private FieldCache.IFloatParser Parser;
                 private FieldCacheImpl.HoldsOneThing<float[]> ValuesRef;
 
-                public UninvertAnonymousInnerClassHelper(FloatCache outerInstance, AtomicReader reader, FieldCache_Fields.IFloatParser parser, FieldCacheImpl.HoldsOneThing<float[]> valuesRef)
+                public UninvertAnonymousInnerClassHelper(FloatCache outerInstance, AtomicReader reader, FieldCache.IFloatParser parser, FieldCacheImpl.HoldsOneThing<float[]> valuesRef)
                 {
                     this.OuterInstance = outerInstance;
                     this.Reader = reader;
@@ -1187,12 +1187,12 @@ namespace Lucene.Net.Search
             }
         }
 
-        public virtual FieldCache_Fields.Longs GetLongs(AtomicReader reader, string field, bool setDocsWithField)
+        public virtual FieldCache.Longs GetLongs(AtomicReader reader, string field, bool setDocsWithField)
         {
             return GetLongs(reader, field, null, setDocsWithField);
         }
 
-        public virtual FieldCache_Fields.Longs GetLongs(AtomicReader reader, string field, FieldCache_Fields.ILongParser parser, bool setDocsWithField)
+        public virtual FieldCache.Longs GetLongs(AtomicReader reader, string field, FieldCache.ILongParser parser, bool setDocsWithField)
         {
             NumericDocValues valuesIn = reader.GetNumericDocValues(field);
             if (valuesIn != null)
@@ -1206,7 +1206,7 @@ namespace Lucene.Net.Search
                 FieldInfo info = reader.FieldInfos.FieldInfo(field);
                 if (info == null)
                 {
-                    return FieldCache_Fields.Longs.EMPTY;
+                    return FieldCache.Longs.EMPTY;
                 }
                 else if (info.HasDocValues())
                 {
@@ -1214,13 +1214,13 @@ namespace Lucene.Net.Search
                 }
                 else if (!info.Indexed)
                 {
-                    return FieldCache_Fields.Longs.EMPTY;
+                    return FieldCache.Longs.EMPTY;
                 }
-                return (FieldCache_Fields.Longs)Caches[typeof(long)].Get(reader, new CacheKey(field, parser), setDocsWithField);
+                return (FieldCache.Longs)Caches[typeof(long)].Get(reader, new CacheKey(field, parser), setDocsWithField);
             }
         }
 
-        private class FieldCache_LongsAnonymousInnerClassHelper : FieldCache_Fields.Longs
+        private class FieldCache_LongsAnonymousInnerClassHelper : FieldCache.Longs
         {
             private readonly FieldCacheImpl OuterInstance;
 
@@ -1238,7 +1238,7 @@ namespace Lucene.Net.Search
             }
         }
 
-        internal class LongsFromArray : FieldCache_Fields.Longs
+        internal class LongsFromArray : FieldCache.Longs
         {
             internal readonly PackedInts.Reader Values;
             internal readonly long MinValue;
@@ -1264,7 +1264,7 @@ namespace Lucene.Net.Search
 
             protected internal override object CreateValue(AtomicReader reader, CacheKey key, bool setDocsWithField)
             {
-                FieldCache_Fields.ILongParser parser = (FieldCache_Fields.ILongParser)key.Custom;
+                FieldCache.ILongParser parser = (FieldCache.ILongParser)key.Custom;
                 if (parser == null)
                 {
                     // Confusing: must delegate to wrapper (vs simply
@@ -1274,11 +1274,11 @@ namespace Lucene.Net.Search
                     // DEFAULT_LONG_PARSER/NUMERIC_UTILS_LONG_PARSER:
                     try
                     {
-                        return Wrapper.GetLongs(reader, key.Field, FieldCache_Fields.DEFAULT_LONG_PARSER, setDocsWithField);
+                        return Wrapper.GetLongs(reader, key.Field, FieldCache.DEFAULT_LONG_PARSER, setDocsWithField);
                     }
                     catch (System.FormatException)
                     {
-                        return Wrapper.GetLongs(reader, key.Field, FieldCache_Fields.NUMERIC_UTILS_LONG_PARSER, setDocsWithField);
+                        return Wrapper.GetLongs(reader, key.Field, FieldCache.NUMERIC_UTILS_LONG_PARSER, setDocsWithField);
                     }
                 }
 
@@ -1305,10 +1305,10 @@ namespace Lucene.Net.Search
                 private readonly LongCache OuterInstance;
 
                 private AtomicReader Reader;
-                private FieldCache_Fields.ILongParser Parser;
+                private FieldCache.ILongParser Parser;
                 private FieldCacheImpl.HoldsOneThing<GrowableWriterAndMinValue> ValuesRef;
 
-                public UninvertAnonymousInnerClassHelper(LongCache outerInstance, AtomicReader reader, FieldCache_Fields.ILongParser parser, FieldCacheImpl.HoldsOneThing<GrowableWriterAndMinValue> valuesRef)
+                public UninvertAnonymousInnerClassHelper(LongCache outerInstance, AtomicReader reader, FieldCache.ILongParser parser, FieldCacheImpl.HoldsOneThing<GrowableWriterAndMinValue> valuesRef)
                 {
                     this.OuterInstance = outerInstance;
                     this.Reader = reader;
@@ -1362,12 +1362,12 @@ namespace Lucene.Net.Search
             }
         }
 
-        public virtual FieldCache_Fields.Doubles GetDoubles(AtomicReader reader, string field, bool setDocsWithField)
+        public virtual FieldCache.Doubles GetDoubles(AtomicReader reader, string field, bool setDocsWithField)
         {
             return GetDoubles(reader, field, null, setDocsWithField);
         }
 
-        public virtual FieldCache_Fields.Doubles GetDoubles(AtomicReader reader, string field, FieldCache_Fields.IDoubleParser parser, bool setDocsWithField)
+        public virtual FieldCache.Doubles GetDoubles(AtomicReader reader, string field, FieldCache.IDoubleParser parser, bool setDocsWithField)
         {
             NumericDocValues valuesIn = reader.GetNumericDocValues(field);
             if (valuesIn != null)
@@ -1381,7 +1381,7 @@ namespace Lucene.Net.Search
                 FieldInfo info = reader.FieldInfos.FieldInfo(field);
                 if (info == null)
                 {
-                    return FieldCache_Fields.Doubles.EMPTY;
+                    return FieldCache.Doubles.EMPTY;
                 }
                 else if (info.HasDocValues())
                 {
@@ -1389,13 +1389,13 @@ namespace Lucene.Net.Search
                 }
                 else if (!info.Indexed)
                 {
-                    return FieldCache_Fields.Doubles.EMPTY;
+                    return FieldCache.Doubles.EMPTY;
                 }
-                return (FieldCache_Fields.Doubles)Caches[typeof(double)].Get(reader, new CacheKey(field, parser), setDocsWithField);
+                return (FieldCache.Doubles)Caches[typeof(double)].Get(reader, new CacheKey(field, parser), setDocsWithField);
             }
         }
 
-        private class FieldCache_DoublesAnonymousInnerClassHelper : FieldCache_Fields.Doubles
+        private class FieldCache_DoublesAnonymousInnerClassHelper : FieldCache.Doubles
         {
             private readonly FieldCacheImpl OuterInstance;
 
@@ -1413,7 +1413,7 @@ namespace Lucene.Net.Search
             }
         }
 
-        internal class DoublesFromArray : FieldCache_Fields.Doubles
+        internal class DoublesFromArray : FieldCache.Doubles
         {
             internal readonly double[] Values;
 
@@ -1437,7 +1437,7 @@ namespace Lucene.Net.Search
 
             protected internal override object CreateValue(AtomicReader reader, CacheKey key, bool setDocsWithField)
             {
-                FieldCache_Fields.IDoubleParser parser = (FieldCache_Fields.IDoubleParser)key.Custom;
+                FieldCache.IDoubleParser parser = (FieldCache.IDoubleParser)key.Custom;
                 if (parser == null)
                 {
                     // Confusing: must delegate to wrapper (vs simply
@@ -1447,11 +1447,11 @@ namespace Lucene.Net.Search
                     // DEFAULT_DOUBLE_PARSER/NUMERIC_UTILS_DOUBLE_PARSER:
                     try
                     {
-                        return Wrapper.GetDoubles(reader, key.Field, FieldCache_Fields.DEFAULT_DOUBLE_PARSER, setDocsWithField);
+                        return Wrapper.GetDoubles(reader, key.Field, FieldCache.DEFAULT_DOUBLE_PARSER, setDocsWithField);
                     }
                     catch (System.FormatException)
                     {
-                        return Wrapper.GetDoubles(reader, key.Field, FieldCache_Fields.NUMERIC_UTILS_DOUBLE_PARSER, setDocsWithField);
+                        return Wrapper.GetDoubles(reader, key.Field, FieldCache.NUMERIC_UTILS_DOUBLE_PARSER, setDocsWithField);
                     }
                 }
 
@@ -1478,10 +1478,10 @@ namespace Lucene.Net.Search
                 private readonly DoubleCache OuterInstance;
 
                 private AtomicReader Reader;
-                private FieldCache_Fields.IDoubleParser Parser;
+                private FieldCache.IDoubleParser Parser;
                 private FieldCacheImpl.HoldsOneThing<double[]> ValuesRef;
 
-                public UninvertAnonymousInnerClassHelper(DoubleCache outerInstance, AtomicReader reader, FieldCache_Fields.IDoubleParser parser, FieldCacheImpl.HoldsOneThing<double[]> valuesRef)
+                public UninvertAnonymousInnerClassHelper(DoubleCache outerInstance, AtomicReader reader, FieldCache.IDoubleParser parser, FieldCacheImpl.HoldsOneThing<double[]> valuesRef)
                 {
                     this.OuterInstance = outerInstance;
                     this.Reader = reader;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/ddec100a/src/Lucene.Net.Core/Search/FieldCacheRangeFilter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Search/FieldCacheRangeFilter.cs b/src/Lucene.Net.Core/Search/FieldCacheRangeFilter.cs
index 7ee7f77..ff40f96 100644
--- a/src/Lucene.Net.Core/Search/FieldCacheRangeFilter.cs
+++ b/src/Lucene.Net.Core/Search/FieldCacheRangeFilter.cs
@@ -33,7 +33,7 @@ namespace Lucene.Net.Search
     using SortedDocValues = Lucene.Net.Index.SortedDocValues;
 
     /// <summary>
-    /// A range filter built on top of a cached single term field (in <seealso cref="FieldCache"/>).
+    /// A range filter built on top of a cached single term field (in <seealso cref="IFieldCache"/>).
     ///
     /// <p>{@code FieldCacheRangeFilter} builds a single cache for the field the first time it is used.
     /// Each subsequent {@code FieldCacheRangeFilter} on the same field then reuses this cache,
@@ -50,9 +50,9 @@ namespace Lucene.Net.Search
     /// LongField} or <seealso cref="DoubleField"/>. But
     /// it has the problem that it only works with exact one value/document (see below).
     ///
-    /// <p>As with all <seealso cref="FieldCache"/> based functionality, {@code FieldCacheRangeFilter} is only valid for
+    /// <p>As with all <seealso cref="IFieldCache"/> based functionality, {@code FieldCacheRangeFilter} is only valid for
     /// fields which exact one term for each document (except for <seealso cref="#newStringRange"/>
-    /// where 0 terms are also allowed). Due to a restriction of <seealso cref="FieldCache"/>, for numeric ranges
+    /// where 0 terms are also allowed). Due to a restriction of <seealso cref="IFieldCache"/>, for numeric ranges
     /// all terms that do not have a numeric value, 0 is assumed.
     ///
     /// <p>Thus it works on dates, prices and other single value fields but will not work on
@@ -60,7 +60,7 @@ namespace Lucene.Net.Search
     /// there is only a single term.
     ///
     /// <p>this class does not have an constructor, use one of the static factory methods available,
-    /// that create a correct instance for different data types supported by <seealso cref="FieldCache"/>.
+    /// that create a correct instance for different data types supported by <seealso cref="IFieldCache"/>.
     /// </summary>
 
     public static class FieldCacheRangeFilter
@@ -96,7 +96,7 @@ namespace Lucene.Net.Search
 
             public override DocIdSet GetDocIdSet(AtomicReaderContext context, Bits acceptDocs)
             {
-                SortedDocValues fcsi = FieldCache_Fields.DEFAULT.GetTermsIndex(context.AtomicReader, field);
+                SortedDocValues fcsi = FieldCache.DEFAULT.GetTermsIndex(context.AtomicReader, field);
                 int lowerPoint = lowerVal == null ? -1 : fcsi.LookupTerm(new BytesRef(lowerVal));
                 int upperPoint = upperVal == null ? -1 : fcsi.LookupTerm(new BytesRef(upperVal));
 
@@ -182,7 +182,7 @@ namespace Lucene.Net.Search
 
             public override DocIdSet GetDocIdSet(AtomicReaderContext context, Bits acceptDocs)
             {
-                SortedDocValues fcsi = FieldCache_Fields.DEFAULT.GetTermsIndex(context.AtomicReader, field);
+                SortedDocValues fcsi = FieldCache.DEFAULT.GetTermsIndex(context.AtomicReader, field);
                 int lowerPoint = lowerVal == null ? -1 : fcsi.LookupTerm(lowerVal);
                 int upperPoint = upperVal == null ? -1 : fcsi.LookupTerm(upperVal);
 
@@ -241,11 +241,11 @@ namespace Lucene.Net.Search
         {
             private class AnonymousClassFieldCacheDocIdSet : FieldCacheDocIdSet
             {
-                private FieldCache_Fields.Bytes values;
+                private FieldCache.Bytes values;
                 private sbyte inclusiveLowerPoint;
                 private sbyte inclusiveUpperPoint;
 
-                internal AnonymousClassFieldCacheDocIdSet(FieldCache_Fields.Bytes values, sbyte inclusiveLowerPoint, sbyte inclusiveUpperPoint, int maxDoc, Bits acceptDocs)
+                internal AnonymousClassFieldCacheDocIdSet(FieldCache.Bytes values, sbyte inclusiveLowerPoint, sbyte inclusiveUpperPoint, int maxDoc, Bits acceptDocs)
                     : base(maxDoc, acceptDocs)
                 {
                     this.values = values;
@@ -260,7 +260,7 @@ namespace Lucene.Net.Search
                 }
             }
 
-            internal AnonymousSbyteFieldCacheRangeFilter(string field, FieldCache_Fields.IParser parser, sbyte? lowerVal, sbyte? upperVal, bool includeLower, bool includeUpper)
+            internal AnonymousSbyteFieldCacheRangeFilter(string field, FieldCache.IParser parser, sbyte? lowerVal, sbyte? upperVal, bool includeLower, bool includeUpper)
                 : base(field, parser, lowerVal, upperVal, includeLower, includeUpper)
             {
             }
@@ -294,7 +294,7 @@ namespace Lucene.Net.Search
                 if (inclusiveLowerPoint > inclusiveUpperPoint)
                     return null;
 
-                var values = FieldCache_Fields.DEFAULT.GetBytes(context.AtomicReader, field, (FieldCache_Fields.IByteParser)parser, false);
+                var values = FieldCache.DEFAULT.GetBytes(context.AtomicReader, field, (FieldCache.IByteParser)parser, false);
 
                 // we only request the usage of termDocs, if the range contains 0
                 return new AnonymousClassFieldCacheDocIdSet(values, inclusiveLowerPoint, inclusiveUpperPoint, context.AtomicReader.MaxDoc, acceptDocs);
@@ -306,11 +306,11 @@ namespace Lucene.Net.Search
         {
             private class AnonymousClassFieldCacheDocIdSet : FieldCacheDocIdSet
             {
-                private FieldCache_Fields.Shorts values;
+                private FieldCache.Shorts values;
                 private short inclusiveLowerPoint;
                 private short inclusiveUpperPoint;
 
-                internal AnonymousClassFieldCacheDocIdSet(FieldCache_Fields.Shorts values, short inclusiveLowerPoint, short inclusiveUpperPoint, int maxDoc, Bits acceptDocs)
+                internal AnonymousClassFieldCacheDocIdSet(FieldCache.Shorts values, short inclusiveLowerPoint, short inclusiveUpperPoint, int maxDoc, Bits acceptDocs)
                     : base(maxDoc, acceptDocs)
                 {
                     this.values = values;
@@ -325,7 +325,7 @@ namespace Lucene.Net.Search
                 }
             }
 
-            internal AnonymousShortFieldCacheRangeFilter(string field, FieldCache_Fields.IParser parser, short? lowerVal, short? upperVal, bool includeLower, bool includeUpper)
+            internal AnonymousShortFieldCacheRangeFilter(string field, FieldCache.IParser parser, short? lowerVal, short? upperVal, bool includeLower, bool includeUpper)
                 : base(field, parser, lowerVal, upperVal, includeLower, includeUpper)
             {
             }
@@ -360,7 +360,7 @@ namespace Lucene.Net.Search
                 if (inclusiveLowerPoint > inclusiveUpperPoint)
                     return null;
 
-                FieldCache_Fields.Shorts values = FieldCache_Fields.DEFAULT.GetShorts(context.AtomicReader, field, (FieldCache_Fields.IShortParser)parser, false);
+                FieldCache.Shorts values = FieldCache.DEFAULT.GetShorts(context.AtomicReader, field, (FieldCache.IShortParser)parser, false);
 
                 // we only request the usage of termDocs, if the range contains 0
                 return new AnonymousClassFieldCacheDocIdSet(values, inclusiveLowerPoint, inclusiveUpperPoint, context.Reader.MaxDoc, acceptDocs);
@@ -372,11 +372,11 @@ namespace Lucene.Net.Search
         {
             private class AnonymousClassFieldCacheDocIdSet : FieldCacheDocIdSet
             {
-                private FieldCache_Fields.Ints values;
+                private FieldCache.Ints values;
                 private int inclusiveLowerPoint;
                 private int inclusiveUpperPoint;
 
-                internal AnonymousClassFieldCacheDocIdSet(FieldCache_Fields.Ints values, int inclusiveLowerPoint, int inclusiveUpperPoint, int maxDoc, Bits acceptDocs)
+                internal AnonymousClassFieldCacheDocIdSet(FieldCache.Ints values, int inclusiveLowerPoint, int inclusiveUpperPoint, int maxDoc, Bits acceptDocs)
                     : base(maxDoc, acceptDocs)
                 {
                     this.values = values;
@@ -391,7 +391,7 @@ namespace Lucene.Net.Search
                 }
             }
 
-            internal AnonymousIntFieldCacheRangeFilter(string field, FieldCache_Fields.IParser parser, int? lowerVal, int? upperVal, bool includeLower, bool includeUpper)
+            internal AnonymousIntFieldCacheRangeFilter(string field, FieldCache.IParser parser, int? lowerVal, int? upperVal, bool includeLower, bool includeUpper)
                 : base(field, parser, lowerVal, upperVal, includeLower, includeUpper)
             {
             }
@@ -426,7 +426,7 @@ namespace Lucene.Net.Search
                 if (inclusiveLowerPoint > inclusiveUpperPoint)
                     return null;
 
-                FieldCache_Fields.Ints values = FieldCache_Fields.DEFAULT.GetInts(context.AtomicReader, field, (FieldCache_Fields.IIntParser)parser, false);
+                FieldCache.Ints values = FieldCache.DEFAULT.GetInts(context.AtomicReader, field, (FieldCache.IIntParser)parser, false);
                 // we only request the usage of termDocs, if the range contains 0
                 return new AnonymousClassFieldCacheDocIdSet(values, inclusiveLowerPoint, inclusiveUpperPoint, context.Reader.MaxDoc, acceptDocs);
             }
@@ -437,11 +437,11 @@ namespace Lucene.Net.Search
         {
             private class AnonymousClassFieldCacheDocIdSet : FieldCacheDocIdSet
             {
-                private FieldCache_Fields.Longs values;
+                private FieldCache.Longs values;
                 private long inclusiveLowerPoint;
                 private long inclusiveUpperPoint;
 
-                internal AnonymousClassFieldCacheDocIdSet(FieldCache_Fields.Longs values, long inclusiveLowerPoint, long inclusiveUpperPoint, int maxDoc, Bits acceptDocs)
+                internal AnonymousClassFieldCacheDocIdSet(FieldCache.Longs values, long inclusiveLowerPoint, long inclusiveUpperPoint, int maxDoc, Bits acceptDocs)
                     : base(maxDoc, acceptDocs)
                 {
                     this.values = values;
@@ -456,7 +456,7 @@ namespace Lucene.Net.Search
                 }
             }
 
-            internal AnonymousLongFieldCacheRangeFilter(string field, FieldCache_Fields.IParser parser, long? lowerVal, long? upperVal, bool includeLower, bool includeUpper)
+            internal AnonymousLongFieldCacheRangeFilter(string field, FieldCache.IParser parser, long? lowerVal, long? upperVal, bool includeLower, bool includeUpper)
                 : base(field, parser, lowerVal, upperVal, includeLower, includeUpper)
             {
             }
@@ -491,7 +491,7 @@ namespace Lucene.Net.Search
                 if (inclusiveLowerPoint > inclusiveUpperPoint)
                     return null;
 
-                FieldCache_Fields.Longs values = FieldCache_Fields.DEFAULT.GetLongs(context.AtomicReader, field, (FieldCache_Fields.ILongParser)parser, false);
+                FieldCache.Longs values = FieldCache.DEFAULT.GetLongs(context.AtomicReader, field, (FieldCache.ILongParser)parser, false);
                 // we only request the usage of termDocs, if the range contains 0
                 return new AnonymousClassFieldCacheDocIdSet(values, inclusiveLowerPoint, inclusiveUpperPoint, context.Reader.MaxDoc, acceptDocs);
             }
@@ -502,11 +502,11 @@ namespace Lucene.Net.Search
         {
             private class AnonymousClassFieldCacheDocIdSet : FieldCacheDocIdSet
             {
-                private FieldCache_Fields.Floats values;
+                private FieldCache.Floats values;
                 private float inclusiveLowerPoint;
                 private float inclusiveUpperPoint;
 
-                internal AnonymousClassFieldCacheDocIdSet(FieldCache_Fields.Floats values, float inclusiveLowerPoint, float inclusiveUpperPoint, int maxDoc, Bits acceptDocs)
+                internal AnonymousClassFieldCacheDocIdSet(FieldCache.Floats values, float inclusiveLowerPoint, float inclusiveUpperPoint, int maxDoc, Bits acceptDocs)
                     : base(maxDoc, acceptDocs)
                 {
                     this.values = values;
@@ -521,7 +521,7 @@ namespace Lucene.Net.Search
                 }
             }
 
-            internal AnonymousFloatFieldCacheRangeFilter(string field, FieldCache_Fields.IParser parser, float? lowerVal, float? upperVal, bool includeLower, bool includeUpper)
+            internal AnonymousFloatFieldCacheRangeFilter(string field, FieldCache.IParser parser, float? lowerVal, float? upperVal, bool includeLower, bool includeUpper)
                 : base(field, parser, lowerVal, upperVal, includeLower, includeUpper)
             {
             }
@@ -560,7 +560,7 @@ namespace Lucene.Net.Search
                 if (inclusiveLowerPoint > inclusiveUpperPoint)
                     return null;
 
-                FieldCache_Fields.Floats values = FieldCache_Fields.DEFAULT.GetFloats(context.AtomicReader, field, (FieldCache_Fields.IFloatParser)parser, false);
+                FieldCache.Floats values = FieldCache.DEFAULT.GetFloats(context.AtomicReader, field, (FieldCache.IFloatParser)parser, false);
 
                 // we only request the usage of termDocs, if the range contains 0
                 return new AnonymousClassFieldCacheDocIdSet(values, inclusiveLowerPoint, inclusiveUpperPoint, context.Reader.MaxDoc, acceptDocs);
@@ -572,11 +572,11 @@ namespace Lucene.Net.Search
         {
             private class AnonymousClassFieldCacheDocIdSet : FieldCacheDocIdSet
             {
-                private FieldCache_Fields.Doubles values;
+                private FieldCache.Doubles values;
                 private double inclusiveLowerPoint;
                 private double inclusiveUpperPoint;
 
-                internal AnonymousClassFieldCacheDocIdSet(FieldCache_Fields.Doubles values, double inclusiveLowerPoint, double inclusiveUpperPoint, int maxDoc, Bits acceptDocs)
+                internal AnonymousClassFieldCacheDocIdSet(FieldCache.Doubles values, double inclusiveLowerPoint, double inclusiveUpperPoint, int maxDoc, Bits acceptDocs)
                     : base(maxDoc, acceptDocs)
                 {
                     this.values = values;
@@ -591,7 +591,7 @@ namespace Lucene.Net.Search
                 }
             }
 
-            internal AnonymousDoubleFieldCacheRangeFilter(string field, FieldCache_Fields.IParser parser, double? lowerVal, double? upperVal, bool includeLower, bool includeUpper)
+            internal AnonymousDoubleFieldCacheRangeFilter(string field, FieldCache.IParser parser, double? lowerVal, double? upperVal, bool includeLower, bool includeUpper)
                 : base(field, parser, lowerVal, upperVal, includeLower, includeUpper)
             {
             }
@@ -630,7 +630,7 @@ namespace Lucene.Net.Search
                 if (inclusiveLowerPoint > inclusiveUpperPoint)
                     return null;
 
-                FieldCache_Fields.Doubles values = FieldCache_Fields.DEFAULT.GetDoubles(context.AtomicReader, field, (FieldCache_Fields.IDoubleParser)parser, false);
+                FieldCache.Doubles values = FieldCache.DEFAULT.GetDoubles(context.AtomicReader, field, (FieldCache.IDoubleParser)parser, false);
 
                 // we only request the usage of termDocs, if the range contains 0
                 return new AnonymousClassFieldCacheDocIdSet(values, inclusiveLowerPoint, inclusiveUpperPoint, context.Reader.MaxDoc, acceptDocs);
@@ -640,7 +640,7 @@ namespace Lucene.Net.Search
         //The functions
 
         /// <summary>
-        /// Creates a string range filter using <seealso cref="FieldCache#getTermsIndex"/>. this works with all
+        /// Creates a string range filter using <seealso cref="IFieldCache#getTermsIndex"/>. 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 <code>null</code>.
         /// </summary>
@@ -650,7 +650,7 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// Creates a BytesRef range filter using <seealso cref="FieldCache#getTermsIndex"/>. this works with all
+        /// Creates a BytesRef range filter using <seealso cref="IFieldCache#getTermsIndex"/>. 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 <code>null</code>.
         /// </summary>
@@ -661,7 +661,7 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// Creates a numeric range filter using <seealso cref="FieldCache#getBytes(AtomicReader,String,boolean)"/>. this works with all
+        /// Creates a numeric range filter using <seealso cref="IFieldCache#getBytes(AtomicReader,String,boolean)"/>. 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 <code>null</code>.
         /// </summary>
@@ -672,18 +672,18 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// Creates a numeric range filter using <seealso cref="FieldCache#getBytes(AtomicReader,String,FieldCache.ByteParser,boolean)"/>. this works with all
+        /// Creates a numeric range filter using <seealso cref="IFieldCache#getBytes(AtomicReader,String,FieldCache.ByteParser,boolean)"/>. 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 <code>null</code>.
         /// </summary>
         [Obsolete]
-        public static FieldCacheRangeFilter<sbyte?> NewByteRange(string field, FieldCache_Fields.IByteParser parser, sbyte? lowerVal, sbyte? upperVal, bool includeLower, bool includeUpper)
+        public static FieldCacheRangeFilter<sbyte?> NewByteRange(string field, FieldCache.IByteParser parser, sbyte? lowerVal, sbyte? upperVal, bool includeLower, bool includeUpper)
         {
             return new AnonymousSbyteFieldCacheRangeFilter(field, parser, lowerVal, upperVal, includeLower, includeUpper);
         }
 
         /// <summary>
-        /// Creates a numeric range filter using <seealso cref="FieldCache#getShorts(AtomicReader,String,boolean)"/>. this works with all
+        /// Creates a numeric range filter using <seealso cref="IFieldCache#getShorts(AtomicReader,String,boolean)"/>. 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 <code>null</code>.
         /// </summary>
@@ -694,18 +694,18 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// Creates a numeric range filter using <seealso cref="FieldCache#getShorts(AtomicReader,String,FieldCache.ShortParser,boolean)"/>. this works with all
+        /// Creates a numeric range filter using <seealso cref="IFieldCache#getShorts(AtomicReader,String,FieldCache.ShortParser,boolean)"/>. 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 <code>null</code>.
         /// </summary>
         [Obsolete]
-        public static FieldCacheRangeFilter<short?> NewShortRange(string field, FieldCache_Fields.IShortParser parser, short? lowerVal, short? upperVal, bool includeLower, bool includeUpper)
+        public static FieldCacheRangeFilter<short?> NewShortRange(string field, FieldCache.IShortParser parser, short? lowerVal, short? upperVal, bool includeLower, bool includeUpper)
         {
             return new AnonymousShortFieldCacheRangeFilter(field, parser, lowerVal, upperVal, includeLower, includeUpper);
         }
 
         /// <summary>
-        /// Creates a numeric range filter using <seealso cref="FieldCache#getInts(AtomicReader,String,boolean)"/>. this works with all
+        /// Creates a numeric range filter using <seealso cref="IFieldCache#getInts(AtomicReader,String,boolean)"/>. 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 <code>null</code>.
         /// </summary>
@@ -715,17 +715,17 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// Creates a numeric range filter using <seealso cref="FieldCache#getInts(AtomicReader,String,FieldCache.IntParser,boolean)"/>. this works with all
+        /// Creates a numeric range filter using <seealso cref="IFieldCache#getInts(AtomicReader,String,FieldCache.IntParser,boolean)"/>. 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 <code>null</code>.
         /// </summary>
-        public static FieldCacheRangeFilter<int?> NewIntRange(string field, FieldCache_Fields.IIntParser parser, int? lowerVal, int? upperVal, bool includeLower, bool includeUpper)
+        public static FieldCacheRangeFilter<int?> NewIntRange(string field, FieldCache.IIntParser parser, int? lowerVal, int? upperVal, bool includeLower, bool includeUpper)
         {
             return new AnonymousIntFieldCacheRangeFilter(field, parser, lowerVal, upperVal, includeLower, includeUpper);
         }
 
         /// <summary>
-        /// Creates a numeric range filter using <seealso cref="FieldCache#getLongs(AtomicReader,String,boolean)"/>. this works with all
+        /// Creates a numeric range filter using <seealso cref="IFieldCache#getLongs(AtomicReader,String,boolean)"/>. 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 <code>null</code>.
         /// </summary>
@@ -735,17 +735,17 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// Creates a numeric range filter using <seealso cref="FieldCache#getLongs(AtomicReader,String,FieldCache.LongParser,boolean)"/>. this works with all
+        /// Creates a numeric range filter using <seealso cref="IFieldCache#getLongs(AtomicReader,String,FieldCache.LongParser,boolean)"/>. 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 <code>null</code>.
         /// </summary>
-        public static FieldCacheRangeFilter<long?> NewLongRange(string field, FieldCache_Fields.ILongParser parser, long? lowerVal, long? upperVal, bool includeLower, bool includeUpper)
+        public static FieldCacheRangeFilter<long?> NewLongRange(string field, FieldCache.ILongParser parser, long? lowerVal, long? upperVal, bool includeLower, bool includeUpper)
         {
             return new AnonymousLongFieldCacheRangeFilter(field, parser, lowerVal, upperVal, includeLower, includeUpper);
         }
 
         /// <summary>
-        /// Creates a numeric range filter using <seealso cref="FieldCache#getFloats(AtomicReader,String,boolean)"/>. this works with all
+        /// Creates a numeric range filter using <seealso cref="IFieldCache#getFloats(AtomicReader,String,boolean)"/>. 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 <code>null</code>.
         /// </summary>
@@ -755,17 +755,17 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// Creates a numeric range filter using <seealso cref="FieldCache#getFloats(AtomicReader,String,FieldCache.FloatParser,boolean)"/>. this works with all
+        /// Creates a numeric range filter using <seealso cref="IFieldCache#getFloats(AtomicReader,String,FieldCache.FloatParser,boolean)"/>. 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 <code>null</code>.
         /// </summary>
-        public static FieldCacheRangeFilter<float?> NewFloatRange(string field, FieldCache_Fields.IFloatParser parser, float? lowerVal, float? upperVal, bool includeLower, bool includeUpper)
+        public static FieldCacheRangeFilter<float?> NewFloatRange(string field, FieldCache.IFloatParser parser, float? lowerVal, float? upperVal, bool includeLower, bool includeUpper)
         {
             return new AnonymousFloatFieldCacheRangeFilter(field, parser, lowerVal, upperVal, includeLower, includeUpper);
         }
 
         /// <summary>
-        /// Creates a numeric range filter using <seealso cref="FieldCache#getDoubles(AtomicReader,String,boolean)"/>. this works with all
+        /// Creates a numeric range filter using <seealso cref="IFieldCache#getDoubles(AtomicReader,String,boolean)"/>. 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 <code>null</code>.
         /// </summary>
@@ -775,11 +775,11 @@ namespace Lucene.Net.Search
         }
 
         /// <summary>
-        /// Creates a numeric range filter using <seealso cref="FieldCache#getDoubles(AtomicReader,String,FieldCache.DoubleParser,boolean)"/>. this works with all
+        /// Creates a numeric range filter using <seealso cref="IFieldCache#getDoubles(AtomicReader,String,FieldCache.DoubleParser,boolean)"/>. 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 <code>null</code>.
         /// </summary>
-        public static FieldCacheRangeFilter<double?> NewDoubleRange(string field, FieldCache_Fields.IDoubleParser parser, double? lowerVal, double? upperVal, bool includeLower, bool includeUpper)
+        public static FieldCacheRangeFilter<double?> NewDoubleRange(string field, FieldCache.IDoubleParser parser, double? lowerVal, double? upperVal, bool includeLower, bool includeUpper)
         {
             return new AnonymousDoubleFieldCacheRangeFilter(field, parser, lowerVal, upperVal, includeLower, includeUpper);
         }
@@ -788,13 +788,13 @@ namespace Lucene.Net.Search
     public abstract class FieldCacheRangeFilter<T> : Filter
     {
         internal readonly string field;
-        internal readonly FieldCache_Fields.IParser parser;
+        internal readonly FieldCache.IParser parser;
         internal readonly T lowerVal;
         internal readonly T upperVal;
         internal readonly bool includeLower;
         internal readonly bool includeUpper;
 
-        protected internal FieldCacheRangeFilter(string field, FieldCache_Fields.IParser parser, T lowerVal, T upperVal, bool includeLower, bool includeUpper)
+        protected internal FieldCacheRangeFilter(string field, FieldCache.IParser parser, T lowerVal, T upperVal, bool includeLower, bool includeUpper)
         {
             this.field = field;
             this.parser = parser;
@@ -1755,7 +1755,7 @@ namespace Lucene.Net.Search
 
         /// <summary>
         /// Returns the current numeric parser ({@code null} for {@code T} is {@code String}} </summary>
-        public virtual FieldCache_Fields.IParser Parser
+        public virtual FieldCache.IParser Parser
         {
             get
             {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/ddec100a/src/Lucene.Net.Core/Search/FieldCacheRewriteMethod.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Search/FieldCacheRewriteMethod.cs b/src/Lucene.Net.Core/Search/FieldCacheRewriteMethod.cs
index 2b7848d..4d5def2 100644
--- a/src/Lucene.Net.Core/Search/FieldCacheRewriteMethod.cs
+++ b/src/Lucene.Net.Core/Search/FieldCacheRewriteMethod.cs
@@ -102,7 +102,7 @@ namespace Lucene.Net.Search
             /// </summary>
             public override DocIdSet GetDocIdSet(AtomicReaderContext context, Bits acceptDocs)
             {
-                SortedDocValues fcsi = FieldCache_Fields.DEFAULT.GetTermsIndex((context.AtomicReader), Query.field);
+                SortedDocValues fcsi = FieldCache.DEFAULT.GetTermsIndex((context.AtomicReader), Query.field);
                 // Cannot use FixedBitSet because we require long index (ord):
                 LongBitSet termSet = new LongBitSet(fcsi.ValueCount);
                 TermsEnum termsEnum = Query.GetTermsEnum(new TermsAnonymousInnerClassHelper(this, fcsi));

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/ddec100a/src/Lucene.Net.Core/Search/FieldCacheTermsFilter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Search/FieldCacheTermsFilter.cs b/src/Lucene.Net.Core/Search/FieldCacheTermsFilter.cs
index c9c7a00..e181108 100644
--- a/src/Lucene.Net.Core/Search/FieldCacheTermsFilter.cs
+++ b/src/Lucene.Net.Core/Search/FieldCacheTermsFilter.cs
@@ -118,11 +118,11 @@ namespace Lucene.Net.Search
             }
         }
 
-        public virtual FieldCache FieldCache
+        public virtual IFieldCache FieldCache
         {
             get
             {
-                return FieldCache_Fields.DEFAULT;
+                return Search.FieldCache.DEFAULT;
             }
         }
 


Mime
View raw message