You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucenenet.apache.org by sy...@apache.org on 2014/09/19 17:05:40 UTC
[2/3] git commit: Sorting the mess with FieldCache and
FieldCache_Fields
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 <it...@code972.com>
Authored: Fri Sep 19 17:56:38 2014 +0300
Committer: Itamar Syn-Hershko <it...@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;
}
}