From 5bae28d57e58b34adf424ded3d5eb4cc53a9332b Mon Sep 17 00:00:00 2001 From: Michael McCandless Date: Tue, 10 Apr 2012 23:21:39 +0000 Subject: [PATCH] LUCENE-3970: rename getUniqueTerm/FieldCount() to size() git-svn-id: https://svn.apache.org/repos/asf/lucene/dev/trunk@1312037 13f79535-47bb-0310-9956-ffa450edef68 --- lucene/CHANGES.txt | 3 +++ .../lucene/index/memory/MemoryIndex.java | 4 ++-- .../apache/lucene/codecs/BlockTermsReader.java | 4 ++-- .../lucene/codecs/BlockTreeTermsReader.java | 4 ++-- .../lucene/codecs/TermVectorsWriter.java | 12 ++++++------ .../lucene/codecs/lucene3x/Lucene3xFields.java | 4 ++-- .../lucene3x/Lucene3xTermVectorsReader.java | 6 +++--- .../lucene40/Lucene40TermVectorsReader.java | 6 +++--- .../codecs/memory/MemoryPostingsFormat.java | 4 ++-- .../perfield/PerFieldPostingsFormat.java | 2 +- .../simpletext/SimpleTextFieldsReader.java | 4 ++-- .../SimpleTextTermVectorsReader.java | 4 ++-- .../org/apache/lucene/index/CheckIndex.java | 4 ++-- .../java/org/apache/lucene/index/Fields.java | 4 ++-- .../lucene/index/FilterAtomicReader.java | 8 ++++---- .../org/apache/lucene/index/MultiFields.java | 2 +- .../org/apache/lucene/index/MultiTerms.java | 2 +- .../lucene/index/ParallelAtomicReader.java | 2 +- .../java/org/apache/lucene/index/Terms.java | 2 +- .../apache/lucene/search/FieldCacheImpl.java | 6 +++--- .../codecs/lucene40/TestReuseDocsEnum.java | 9 ++++----- .../apache/lucene/document/TestDocument.java | 3 +-- .../lucene/index/TestDocumentWriter.java | 4 ++-- .../apache/lucene/index/TestDuelingCodecs.java | 8 ++++---- .../apache/lucene/index/TestSegmentMerger.java | 4 +--- .../apache/lucene/index/TestSegmentReader.java | 4 ++-- .../lucene/index/TestStressIndexing2.java | 2 +- .../lucene/index/TestTermVectorsReader.java | 10 +++++----- .../lucene/search/FieldCacheRewriteMethod.java | 2 +- .../apache/lucene/search/TestTermVectors.java | 18 +++++++++--------- .../codecs/ramonly/RAMOnlyPostingsFormat.java | 4 ++-- .../lucene/index/FieldFilterAtomicReader.java | 2 +- .../analysis/sinks/TestTeeSinkTokenFilter.java | 3 +-- .../benchmark/byTask/TestPerfTasksLogic.java | 2 +- .../solr/handler/admin/LukeRequestHandler.java | 2 +- 35 files changed, 81 insertions(+), 83 deletions(-) diff --git a/lucene/CHANGES.txt b/lucene/CHANGES.txt index 224c9992dda..7ee80149cdb 100644 --- a/lucene/CHANGES.txt +++ b/lucene/CHANGES.txt @@ -259,6 +259,9 @@ Changes in backwards compatibility policy * LUCENE-2000: clone() now returns covariant types where possible. (ryan) +* LUCENE-3970: Rename Fields.getUniqueFieldCount -> .size() and + Terms.getUniqueTermCount -> .size(). (Iulius Curt via Mike McCandless) + Changes in Runtime Behavior * LUCENE-2846: omitNorms now behaves like omitTermFrequencyAndPositions, if you diff --git a/lucene/contrib/memory/src/java/org/apache/lucene/index/memory/MemoryIndex.java b/lucene/contrib/memory/src/java/org/apache/lucene/index/memory/MemoryIndex.java index af9c5b09d1b..ab6b7ca795b 100644 --- a/lucene/contrib/memory/src/java/org/apache/lucene/index/memory/MemoryIndex.java +++ b/lucene/contrib/memory/src/java/org/apache/lucene/index/memory/MemoryIndex.java @@ -759,7 +759,7 @@ public class MemoryIndex { } @Override - public long getUniqueTermCount() { + public long size() { return info.sortedTerms.length; } @@ -785,7 +785,7 @@ public class MemoryIndex { } @Override - public int getUniqueFieldCount() { + public int size() { return sortedFields.length; } } diff --git a/lucene/core/src/java/org/apache/lucene/codecs/BlockTermsReader.java b/lucene/core/src/java/org/apache/lucene/codecs/BlockTermsReader.java index 0c892c2da58..6e523545cf9 100644 --- a/lucene/core/src/java/org/apache/lucene/codecs/BlockTermsReader.java +++ b/lucene/core/src/java/org/apache/lucene/codecs/BlockTermsReader.java @@ -202,7 +202,7 @@ public class BlockTermsReader extends FieldsProducer { } @Override - public int getUniqueFieldCount() { + public int size() { return fields.size(); } @@ -261,7 +261,7 @@ public class BlockTermsReader extends FieldsProducer { } @Override - public long getUniqueTermCount() { + public long size() { return numTerms; } diff --git a/lucene/core/src/java/org/apache/lucene/codecs/BlockTreeTermsReader.java b/lucene/core/src/java/org/apache/lucene/codecs/BlockTreeTermsReader.java index 97543020467..cd70abbefa2 100644 --- a/lucene/core/src/java/org/apache/lucene/codecs/BlockTreeTermsReader.java +++ b/lucene/core/src/java/org/apache/lucene/codecs/BlockTreeTermsReader.java @@ -216,7 +216,7 @@ public class BlockTreeTermsReader extends FieldsProducer { } @Override - public int getUniqueFieldCount() { + public int size() { return fields.size(); } @@ -455,7 +455,7 @@ public class BlockTreeTermsReader extends FieldsProducer { } @Override - public long getUniqueTermCount() { + public long size() { return numTerms; } diff --git a/lucene/core/src/java/org/apache/lucene/codecs/TermVectorsWriter.java b/lucene/core/src/java/org/apache/lucene/codecs/TermVectorsWriter.java index 1f30e9a4ec0..b356b233719 100644 --- a/lucene/core/src/java/org/apache/lucene/codecs/TermVectorsWriter.java +++ b/lucene/core/src/java/org/apache/lucene/codecs/TermVectorsWriter.java @@ -166,17 +166,17 @@ public abstract class TermVectorsWriter implements Closeable { /** Safe (but, slowish) default method to write every * vector field in the document. This default * implementation requires that the vectors implement - * both Fields.getUniqueFieldCount and - * Terms.getUniqueTermCount. */ + * both Fields.size and + * Terms.size. */ protected final void addAllDocVectors(Fields vectors, FieldInfos fieldInfos) throws IOException { if (vectors == null) { startDocument(0); return; } - final int numFields = vectors.getUniqueFieldCount(); + final int numFields = vectors.size(); if (numFields == -1) { - throw new IllegalStateException("vectors.getUniqueFieldCount() must be implemented (it returned -1)"); + throw new IllegalStateException("vectors.size() must be implemented (it returned -1)"); } startDocument(numFields); @@ -195,9 +195,9 @@ public abstract class TermVectorsWriter implements Closeable { // FieldsEnum shouldn't lie... continue; } - final int numTerms = (int) terms.getUniqueTermCount(); + final int numTerms = (int) terms.size(); if (numTerms == -1) { - throw new IllegalStateException("vector.getUniqueTermCount() must be implemented (it returned -1)"); + throw new IllegalStateException("terms.size() must be implemented (it returned -1)"); } final TermsEnum termsEnum = terms.iterator(null); diff --git a/lucene/core/src/java/org/apache/lucene/codecs/lucene3x/Lucene3xFields.java b/lucene/core/src/java/org/apache/lucene/codecs/lucene3x/Lucene3xFields.java index a3edb7bad03..621fe44f481 100644 --- a/lucene/core/src/java/org/apache/lucene/codecs/lucene3x/Lucene3xFields.java +++ b/lucene/core/src/java/org/apache/lucene/codecs/lucene3x/Lucene3xFields.java @@ -161,7 +161,7 @@ class Lucene3xFields extends FieldsProducer { } @Override - public int getUniqueFieldCount() { + public int size() { return preTerms.size(); } @@ -246,7 +246,7 @@ class Lucene3xFields extends FieldsProducer { } @Override - public long getUniqueTermCount() throws IOException { + public long size() throws IOException { return -1; } diff --git a/lucene/core/src/java/org/apache/lucene/codecs/lucene3x/Lucene3xTermVectorsReader.java b/lucene/core/src/java/org/apache/lucene/codecs/lucene3x/Lucene3xTermVectorsReader.java index 62406fc8954..c66e0584dee 100644 --- a/lucene/core/src/java/org/apache/lucene/codecs/lucene3x/Lucene3xTermVectorsReader.java +++ b/lucene/core/src/java/org/apache/lucene/codecs/lucene3x/Lucene3xTermVectorsReader.java @@ -270,7 +270,7 @@ class Lucene3xTermVectorsReader extends TermVectorsReader { } @Override - public int getUniqueFieldCount() { + public int size() { if (fieldNumbers == null) { return 0; } else { @@ -307,7 +307,7 @@ class Lucene3xTermVectorsReader extends TermVectorsReader { } @Override - public long getUniqueTermCount() { + public long size() { return numTerms; } @@ -660,7 +660,7 @@ class Lucene3xTermVectorsReader extends TermVectorsReader { } if (tvx != null) { Fields fields = new TVFields(docID); - if (fields.getUniqueFieldCount() == 0) { + if (fields.size() == 0) { // TODO: we can improve writer here, eg write 0 into // tvx file, so we know on first read from tvx that // this doc has no TVs diff --git a/lucene/core/src/java/org/apache/lucene/codecs/lucene40/Lucene40TermVectorsReader.java b/lucene/core/src/java/org/apache/lucene/codecs/lucene40/Lucene40TermVectorsReader.java index af223fe6451..8e83f6d0c7b 100644 --- a/lucene/core/src/java/org/apache/lucene/codecs/lucene40/Lucene40TermVectorsReader.java +++ b/lucene/core/src/java/org/apache/lucene/codecs/lucene40/Lucene40TermVectorsReader.java @@ -300,7 +300,7 @@ public class Lucene40TermVectorsReader extends TermVectorsReader { } @Override - public int getUniqueFieldCount() { + public int size() { if (fieldNumbers == null) { return 0; } else { @@ -335,7 +335,7 @@ public class Lucene40TermVectorsReader extends TermVectorsReader { } @Override - public long getUniqueTermCount() { + public long size() { return numTerms; } @@ -674,7 +674,7 @@ public class Lucene40TermVectorsReader extends TermVectorsReader { } if (tvx != null) { Fields fields = new TVFields(docID); - if (fields.getUniqueFieldCount() == 0) { + if (fields.size() == 0) { // TODO: we can improve writer here, eg write 0 into // tvx file, so we know on first read from tvx that // this doc has no TVs diff --git a/lucene/core/src/java/org/apache/lucene/codecs/memory/MemoryPostingsFormat.java b/lucene/core/src/java/org/apache/lucene/codecs/memory/MemoryPostingsFormat.java index 89d8bb359f1..8badc9ba7e3 100644 --- a/lucene/core/src/java/org/apache/lucene/codecs/memory/MemoryPostingsFormat.java +++ b/lucene/core/src/java/org/apache/lucene/codecs/memory/MemoryPostingsFormat.java @@ -824,7 +824,7 @@ public class MemoryPostingsFormat extends PostingsFormat { } @Override - public long getUniqueTermCount() throws IOException { + public long size() throws IOException { return termCount; } @@ -888,7 +888,7 @@ public class MemoryPostingsFormat extends PostingsFormat { } @Override - public int getUniqueFieldCount() { + public int size() { return fields.size(); } diff --git a/lucene/core/src/java/org/apache/lucene/codecs/perfield/PerFieldPostingsFormat.java b/lucene/core/src/java/org/apache/lucene/codecs/perfield/PerFieldPostingsFormat.java index e4436835af2..23cb6bdc03d 100644 --- a/lucene/core/src/java/org/apache/lucene/codecs/perfield/PerFieldPostingsFormat.java +++ b/lucene/core/src/java/org/apache/lucene/codecs/perfield/PerFieldPostingsFormat.java @@ -248,7 +248,7 @@ public abstract class PerFieldPostingsFormat extends PostingsFormat { } @Override - public int getUniqueFieldCount() { + public int size() { return fields.size(); } diff --git a/lucene/core/src/java/org/apache/lucene/codecs/simpletext/SimpleTextFieldsReader.java b/lucene/core/src/java/org/apache/lucene/codecs/simpletext/SimpleTextFieldsReader.java index af4a826b531..c3b252df204 100644 --- a/lucene/core/src/java/org/apache/lucene/codecs/simpletext/SimpleTextFieldsReader.java +++ b/lucene/core/src/java/org/apache/lucene/codecs/simpletext/SimpleTextFieldsReader.java @@ -596,7 +596,7 @@ class SimpleTextFieldsReader extends FieldsProducer { } @Override - public long getUniqueTermCount() { + public long size() { return (long) termCount; } @@ -641,7 +641,7 @@ class SimpleTextFieldsReader extends FieldsProducer { } @Override - public int getUniqueFieldCount() { + public int size() { return -1; } diff --git a/lucene/core/src/java/org/apache/lucene/codecs/simpletext/SimpleTextTermVectorsReader.java b/lucene/core/src/java/org/apache/lucene/codecs/simpletext/SimpleTextTermVectorsReader.java index 1aeabdd6a4c..03d6825f1a7 100644 --- a/lucene/core/src/java/org/apache/lucene/codecs/simpletext/SimpleTextTermVectorsReader.java +++ b/lucene/core/src/java/org/apache/lucene/codecs/simpletext/SimpleTextTermVectorsReader.java @@ -257,7 +257,7 @@ public class SimpleTextTermVectorsReader extends TermVectorsReader { } @Override - public int getUniqueFieldCount() throws IOException { + public int size() throws IOException { return fields.size(); } } @@ -281,7 +281,7 @@ public class SimpleTextTermVectorsReader extends TermVectorsReader { } @Override - public long getUniqueTermCount() throws IOException { + public long size() throws IOException { return terms.size(); } diff --git a/lucene/core/src/java/org/apache/lucene/index/CheckIndex.java b/lucene/core/src/java/org/apache/lucene/index/CheckIndex.java index 36836842b90..610f39a24a7 100644 --- a/lucene/core/src/java/org/apache/lucene/index/CheckIndex.java +++ b/lucene/core/src/java/org/apache/lucene/index/CheckIndex.java @@ -1051,7 +1051,7 @@ public class CheckIndex { long termCount = -1; if (status.termCount-termCountStart > 0) { - termCount = fields.terms(field).getUniqueTermCount(); + termCount = fields.terms(field).size(); if (termCount != -1 && termCount != status.termCount - termCountStart) { throw new RuntimeException("termCount mismatch " + termCount + " vs " + (status.termCount - termCountStart)); @@ -1104,7 +1104,7 @@ public class CheckIndex { } } - int fieldCount = fields.getUniqueFieldCount(); + int fieldCount = fields.size(); if (fieldCount != -1) { if (fieldCount < 0) { diff --git a/lucene/core/src/java/org/apache/lucene/index/Fields.java b/lucene/core/src/java/org/apache/lucene/index/Fields.java index 81b1dbdf6e3..4cfe57af046 100644 --- a/lucene/core/src/java/org/apache/lucene/index/Fields.java +++ b/lucene/core/src/java/org/apache/lucene/index/Fields.java @@ -36,7 +36,7 @@ public abstract class Fields { * measure isn't stored by the codec. Note that, just like * other term measures, this measure does not take deleted * documents into account. */ - public abstract int getUniqueFieldCount() throws IOException; + public abstract int size() throws IOException; /** Returns the number of terms for all fields, or -1 if this * measure isn't stored by the codec. Note that, just like @@ -53,7 +53,7 @@ public abstract class Fields { } Terms terms = terms(field); if (terms != null) { - final long termCount = terms.getUniqueTermCount(); + final long termCount = terms.size(); if (termCount == -1) { return -1; } diff --git a/lucene/core/src/java/org/apache/lucene/index/FilterAtomicReader.java b/lucene/core/src/java/org/apache/lucene/index/FilterAtomicReader.java index e1a302f48e1..cc67c40e5f1 100644 --- a/lucene/core/src/java/org/apache/lucene/index/FilterAtomicReader.java +++ b/lucene/core/src/java/org/apache/lucene/index/FilterAtomicReader.java @@ -56,8 +56,8 @@ public class FilterAtomicReader extends AtomicReader { } @Override - public int getUniqueFieldCount() throws IOException { - return in.getUniqueFieldCount(); + public int size() throws IOException { + return in.size(); } @Override @@ -86,8 +86,8 @@ public class FilterAtomicReader extends AtomicReader { } @Override - public long getUniqueTermCount() throws IOException { - return in.getUniqueTermCount(); + public long size() throws IOException { + return in.size(); } @Override diff --git a/lucene/core/src/java/org/apache/lucene/index/MultiFields.java b/lucene/core/src/java/org/apache/lucene/index/MultiFields.java index e2df431fb56..9bd226cdc89 100644 --- a/lucene/core/src/java/org/apache/lucene/index/MultiFields.java +++ b/lucene/core/src/java/org/apache/lucene/index/MultiFields.java @@ -228,7 +228,7 @@ public final class MultiFields extends Fields { } @Override - public int getUniqueFieldCount() { + public int size() { return -1; } diff --git a/lucene/core/src/java/org/apache/lucene/index/MultiTerms.java b/lucene/core/src/java/org/apache/lucene/index/MultiTerms.java index 14c1f5df8c8..c18ac6cc92e 100644 --- a/lucene/core/src/java/org/apache/lucene/index/MultiTerms.java +++ b/lucene/core/src/java/org/apache/lucene/index/MultiTerms.java @@ -96,7 +96,7 @@ public final class MultiTerms extends Terms { } @Override - public long getUniqueTermCount() throws IOException { + public long size() throws IOException { return -1; } diff --git a/lucene/core/src/java/org/apache/lucene/index/ParallelAtomicReader.java b/lucene/core/src/java/org/apache/lucene/index/ParallelAtomicReader.java index 545eead433a..8e76d37520b 100644 --- a/lucene/core/src/java/org/apache/lucene/index/ParallelAtomicReader.java +++ b/lucene/core/src/java/org/apache/lucene/index/ParallelAtomicReader.java @@ -197,7 +197,7 @@ public final class ParallelAtomicReader extends AtomicReader { } @Override - public int getUniqueFieldCount() throws IOException { + public int size() throws IOException { return fields.size(); } } diff --git a/lucene/core/src/java/org/apache/lucene/index/Terms.java b/lucene/core/src/java/org/apache/lucene/index/Terms.java index 174ddce870b..435837aef1d 100644 --- a/lucene/core/src/java/org/apache/lucene/index/Terms.java +++ b/lucene/core/src/java/org/apache/lucene/index/Terms.java @@ -81,7 +81,7 @@ public abstract class Terms { * measure isn't stored by the codec. Note that, just like * other term measures, this measure does not take deleted * documents into account. */ - public abstract long getUniqueTermCount() throws IOException; + public abstract long size() throws IOException; /** Returns the sum of {@link TermsEnum#totalTermFreq} for * all terms in this field, or -1 if this measure isn't diff --git a/lucene/core/src/java/org/apache/lucene/search/FieldCacheImpl.java b/lucene/core/src/java/org/apache/lucene/search/FieldCacheImpl.java index 0c2513ca157..79b7500688b 100644 --- a/lucene/core/src/java/org/apache/lucene/search/FieldCacheImpl.java +++ b/lucene/core/src/java/org/apache/lucene/search/FieldCacheImpl.java @@ -1114,7 +1114,7 @@ class FieldCacheImpl implements FieldCache { // is fine -- GrowableWriter will reallocate as needed long numUniqueTerms = 0; try { - numUniqueTerms = terms.getUniqueTermCount(); + numUniqueTerms = terms.size(); } catch (UnsupportedOperationException uoe) { numUniqueTerms = -1; } @@ -1165,7 +1165,7 @@ class FieldCacheImpl implements FieldCache { if (termOrd == termOrdToBytesOffset.size()) { // NOTE: this code only runs if the incoming // reader impl doesn't implement - // getUniqueTermCount (which should be uncommon) + // size (which should be uncommon) termOrdToBytesOffset = termOrdToBytesOffset.resize(ArrayUtil.oversize(1+termOrd, 1)); } termOrdToBytesOffset.set(termOrd, bytes.copyUsingLengthPrefix(term)); @@ -1252,7 +1252,7 @@ class FieldCacheImpl implements FieldCache { // is fine -- GrowableWriter will reallocate as needed long numUniqueTerms = 0; try { - numUniqueTerms = terms.getUniqueTermCount(); + numUniqueTerms = terms.size(); } catch (UnsupportedOperationException uoe) { numUniqueTerms = -1; } diff --git a/lucene/core/src/test/org/apache/lucene/codecs/lucene40/TestReuseDocsEnum.java b/lucene/core/src/test/org/apache/lucene/codecs/lucene40/TestReuseDocsEnum.java index 8d1c7740888..51346cb7998 100644 --- a/lucene/core/src/test/org/apache/lucene/codecs/lucene40/TestReuseDocsEnum.java +++ b/lucene/core/src/test/org/apache/lucene/codecs/lucene40/TestReuseDocsEnum.java @@ -21,7 +21,6 @@ import java.util.Random; import org.apache.lucene.analysis.MockAnalyzer; import org.apache.lucene.codecs.Codec; -import org.apache.lucene.codecs.lucene40.Lucene40PostingsFormat; import org.apache.lucene.index.AtomicReader; import org.apache.lucene.index.DirectoryReader; import org.apache.lucene.index.DocsEnum; @@ -63,7 +62,7 @@ public class TestReuseDocsEnum extends LuceneTestCase { enums.put(docs, true); } - assertEquals(terms.getUniqueTermCount(), enums.size()); + assertEquals(terms.size(), enums.size()); } }.run(); IOUtils.close(writer, open, dir); @@ -100,7 +99,7 @@ public class TestReuseDocsEnum extends LuceneTestCase { docs = iterator.docs(new Bits.MatchNoBits(open.maxDoc()), docs, random.nextBoolean()); enums.put(docs, true); } - assertEquals(terms.getUniqueTermCount(), enums.size()); + assertEquals(terms.size(), enums.size()); enums.clear(); iterator = terms.iterator(null); @@ -141,7 +140,7 @@ public class TestReuseDocsEnum extends LuceneTestCase { docs = iterator.docs(null, randomDocsEnum("body", term, sequentialSubReaders2, bits), random.nextBoolean()); enums.put(docs, true); } - assertEquals(terms.getUniqueTermCount(), enums.size()); + assertEquals(terms.size(), enums.size()); iterator = terms.iterator(null); enums.clear(); @@ -150,7 +149,7 @@ public class TestReuseDocsEnum extends LuceneTestCase { docs = iterator.docs(bits, randomDocsEnum("body", term, sequentialSubReaders2, bits), random.nextBoolean()); enums.put(docs, true); } - assertEquals(terms.getUniqueTermCount(), enums.size()); + assertEquals(terms.size(), enums.size()); } IOUtils.close(writer, firstReader, secondReader, dir); } diff --git a/lucene/core/src/test/org/apache/lucene/document/TestDocument.java b/lucene/core/src/test/org/apache/lucene/document/TestDocument.java index 90a11dfe213..e23a94439f4 100644 --- a/lucene/core/src/test/org/apache/lucene/document/TestDocument.java +++ b/lucene/core/src/test/org/apache/lucene/document/TestDocument.java @@ -21,7 +21,6 @@ import java.io.StringReader; import org.apache.lucene.analysis.EmptyTokenizer; import org.apache.lucene.analysis.MockAnalyzer; -import org.apache.lucene.analysis.Tokenizer; import org.apache.lucene.index.DirectoryReader; import org.apache.lucene.index.DocsAndPositionsEnum; import org.apache.lucene.index.Fields; @@ -345,7 +344,7 @@ public class TestDocument extends LuceneTestCase { Fields tvFields = r.getTermVectors(0); Terms tvs = tvFields.terms(field); assertNotNull(tvs); - assertEquals(2, tvs.getUniqueTermCount()); + assertEquals(2, tvs.size()); TermsEnum tvsEnum = tvs.iterator(null); assertEquals(new BytesRef("abc"), tvsEnum.next()); final DocsAndPositionsEnum dpEnum = tvsEnum.docsAndPositions(null, null, false); diff --git a/lucene/core/src/test/org/apache/lucene/index/TestDocumentWriter.java b/lucene/core/src/test/org/apache/lucene/index/TestDocumentWriter.java index 77032dab11c..512bb31e167 100644 --- a/lucene/core/src/test/org/apache/lucene/index/TestDocumentWriter.java +++ b/lucene/core/src/test/org/apache/lucene/index/TestDocumentWriter.java @@ -290,11 +290,11 @@ public class TestDocumentWriter extends LuceneTestCase { // f1 Terms tfv1 = reader.getTermVectors(0).terms("f1"); assertNotNull(tfv1); - assertEquals("the 'with_tv' setting should rule!",2,tfv1.getUniqueTermCount()); + assertEquals("the 'with_tv' setting should rule!",2,tfv1.size()); // f2 Terms tfv2 = reader.getTermVectors(0).terms("f2"); assertNotNull(tfv2); - assertEquals("the 'with_tv' setting should rule!",2,tfv2.getUniqueTermCount()); + assertEquals("the 'with_tv' setting should rule!",2,tfv2.size()); reader.close(); } diff --git a/lucene/core/src/test/org/apache/lucene/index/TestDuelingCodecs.java b/lucene/core/src/test/org/apache/lucene/index/TestDuelingCodecs.java index 7c416ca2f0d..ed7d5f4b75f 100644 --- a/lucene/core/src/test/org/apache/lucene/index/TestDuelingCodecs.java +++ b/lucene/core/src/test/org/apache/lucene/index/TestDuelingCodecs.java @@ -184,8 +184,8 @@ public class TestDuelingCodecs extends LuceneTestCase { * checks that top-level statistics on Fields are the same */ public void assertFieldStatistics(Fields leftFields, Fields rightFields) throws Exception { - if (leftFields.getUniqueFieldCount() != -1 && rightFields.getUniqueFieldCount() != -1) { - assertEquals(info, leftFields.getUniqueFieldCount(), rightFields.getUniqueFieldCount()); + if (leftFields.size() != -1 && rightFields.size() != -1) { + assertEquals(info, leftFields.size(), rightFields.size()); } if (leftFields.getUniqueTermCount() != -1 && rightFields.getUniqueTermCount() != -1) { @@ -238,8 +238,8 @@ public class TestDuelingCodecs extends LuceneTestCase { if (leftTerms.getSumTotalTermFreq() != -1 && rightTerms.getSumTotalTermFreq() != -1) { assertEquals(info, leftTerms.getSumTotalTermFreq(), rightTerms.getSumTotalTermFreq()); } - if (leftTerms.getUniqueTermCount() != -1 && rightTerms.getUniqueTermCount() != -1) { - assertEquals(info, leftTerms.getUniqueTermCount(), rightTerms.getUniqueTermCount()); + if (leftTerms.size() != -1 && rightTerms.size() != -1) { + assertEquals(info, leftTerms.size(), rightTerms.size()); } } diff --git a/lucene/core/src/test/org/apache/lucene/index/TestSegmentMerger.java b/lucene/core/src/test/org/apache/lucene/index/TestSegmentMerger.java index 242063eafdd..2ee7d1f3b19 100644 --- a/lucene/core/src/test/org/apache/lucene/index/TestSegmentMerger.java +++ b/lucene/core/src/test/org/apache/lucene/index/TestSegmentMerger.java @@ -19,10 +19,8 @@ package org.apache.lucene.index; import java.io.IOException; -import org.apache.lucene.analysis.MockAnalyzer; import org.apache.lucene.codecs.Codec; import org.apache.lucene.document.Document; -import org.apache.lucene.document.TextField; import org.apache.lucene.search.DocIdSetIterator; import org.apache.lucene.store.Directory; import org.apache.lucene.util.BytesRef; @@ -120,7 +118,7 @@ public class TestSegmentMerger extends LuceneTestCase { Terms vector = mergedReader.getTermVectors(0).terms(DocHelper.TEXT_FIELD_2_KEY); assertNotNull(vector); - assertEquals(3, vector.getUniqueTermCount()); + assertEquals(3, vector.size()); TermsEnum termsEnum = vector.iterator(null); int i = 0; diff --git a/lucene/core/src/test/org/apache/lucene/index/TestSegmentReader.java b/lucene/core/src/test/org/apache/lucene/index/TestSegmentReader.java index c84382b9a23..870f5fe3698 100644 --- a/lucene/core/src/test/org/apache/lucene/index/TestSegmentReader.java +++ b/lucene/core/src/test/org/apache/lucene/index/TestSegmentReader.java @@ -193,7 +193,7 @@ public class TestSegmentReader extends LuceneTestCase { public void testTermVectors() throws IOException { Terms result = reader.getTermVectors(0).terms(DocHelper.TEXT_FIELD_2_KEY); assertNotNull(result); - assertEquals(3, result.getUniqueTermCount()); + assertEquals(3, result.size()); TermsEnum termsEnum = result.iterator(null); while(termsEnum.next() != null) { String term = termsEnum.term().utf8ToString(); @@ -204,6 +204,6 @@ public class TestSegmentReader extends LuceneTestCase { Fields results = reader.getTermVectors(0); assertTrue(results != null); - assertEquals("We do not have 3 term freq vectors", 3, results.getUniqueFieldCount()); + assertEquals("We do not have 3 term freq vectors", 3, results.size()); } } diff --git a/lucene/core/src/test/org/apache/lucene/index/TestStressIndexing2.java b/lucene/core/src/test/org/apache/lucene/index/TestStressIndexing2.java index e309fbf9cce..304bf73fa5d 100644 --- a/lucene/core/src/test/org/apache/lucene/index/TestStressIndexing2.java +++ b/lucene/core/src/test/org/apache/lucene/index/TestStressIndexing2.java @@ -600,7 +600,7 @@ public class TestStressIndexing2 extends LuceneTestCase { public static void verifyEquals(Fields d1, Fields d2) throws IOException { if (d1 == null) { - assertTrue(d2 == null || d2.getUniqueFieldCount() == 0); + assertTrue(d2 == null || d2.size() == 0); return; } assertTrue(d2 != null); diff --git a/lucene/core/src/test/org/apache/lucene/index/TestTermVectorsReader.java b/lucene/core/src/test/org/apache/lucene/index/TestTermVectorsReader.java index 8fd532c5955..73b49e91093 100644 --- a/lucene/core/src/test/org/apache/lucene/index/TestTermVectorsReader.java +++ b/lucene/core/src/test/org/apache/lucene/index/TestTermVectorsReader.java @@ -204,7 +204,7 @@ public class TestTermVectorsReader extends LuceneTestCase { for (int j = 0; j < 5; j++) { Terms vector = reader.get(j).terms(testFields[0]); assertNotNull(vector); - assertEquals(testTerms.length, vector.getUniqueTermCount()); + assertEquals(testTerms.length, vector.size()); TermsEnum termsEnum = vector.iterator(null); for (int i = 0; i < testTerms.length; i++) { final BytesRef text = termsEnum.next(); @@ -223,7 +223,7 @@ public class TestTermVectorsReader extends LuceneTestCase { for (int j = 0; j < 5; j++) { Terms vector = reader.get(j).terms(testFields[0]); assertNotNull(vector); - assertEquals(testTerms.length, vector.getUniqueTermCount()); + assertEquals(testTerms.length, vector.size()); TermsEnum termsEnum = vector.iterator(null); DocsEnum docsEnum = null; for (int i = 0; i < testTerms.length; i++) { @@ -250,7 +250,7 @@ public class TestTermVectorsReader extends LuceneTestCase { BytesRef[] terms; Terms vector = reader.get(0).terms(testFields[0]); assertNotNull(vector); - assertEquals(testTerms.length, vector.getUniqueTermCount()); + assertEquals(testTerms.length, vector.size()); TermsEnum termsEnum = vector.iterator(null); DocsAndPositionsEnum dpEnum = null; for (int i = 0; i < testTerms.length; i++) { @@ -287,7 +287,7 @@ public class TestTermVectorsReader extends LuceneTestCase { Terms freqVector = reader.get(0).terms(testFields[1]); //no pos, no offset assertNotNull(freqVector); - assertEquals(testTerms.length, freqVector.getUniqueTermCount()); + assertEquals(testTerms.length, freqVector.size()); termsEnum = freqVector.iterator(null); assertNotNull(termsEnum); for (int i = 0; i < testTerms.length; i++) { @@ -306,7 +306,7 @@ public class TestTermVectorsReader extends LuceneTestCase { assertNotNull(vector); TermsEnum termsEnum = vector.iterator(null); assertNotNull(termsEnum); - assertEquals(testTerms.length, vector.getUniqueTermCount()); + assertEquals(testTerms.length, vector.size()); DocsAndPositionsEnum dpEnum = null; for (int i = 0; i < testTerms.length; i++) { final BytesRef text = termsEnum.next(); diff --git a/lucene/core/src/test/org/apache/lucene/search/FieldCacheRewriteMethod.java b/lucene/core/src/test/org/apache/lucene/search/FieldCacheRewriteMethod.java index edfef5c8965..2abdf76ed8d 100644 --- a/lucene/core/src/test/org/apache/lucene/search/FieldCacheRewriteMethod.java +++ b/lucene/core/src/test/org/apache/lucene/search/FieldCacheRewriteMethod.java @@ -119,7 +119,7 @@ public final class FieldCacheRewriteMethod extends MultiTermQuery.RewriteMethod } @Override - public long getUniqueTermCount() throws IOException { + public long size() throws IOException { return -1; } }); diff --git a/lucene/core/src/test/org/apache/lucene/search/TestTermVectors.java b/lucene/core/src/test/org/apache/lucene/search/TestTermVectors.java index 9e2d39152bd..838ca96b1ce 100644 --- a/lucene/core/src/test/org/apache/lucene/search/TestTermVectors.java +++ b/lucene/core/src/test/org/apache/lucene/search/TestTermVectors.java @@ -98,7 +98,7 @@ public class TestTermVectors extends LuceneTestCase { for (int i = 0; i < hits.length; i++) { Fields vectors = searcher.reader.getTermVectors(hits[i].doc); assertNotNull(vectors); - assertEquals("doc=" + hits[i].doc + " tv=" + vectors, 1, vectors.getUniqueFieldCount()); + assertEquals("doc=" + hits[i].doc + " tv=" + vectors, 1, vectors.size()); } Terms vector; vector = searcher.reader.getTermVectors(hits[0].doc).terms("noTV"); @@ -121,13 +121,13 @@ public class TestTermVectors extends LuceneTestCase { IndexReader reader = writer.getReader(); writer.close(); Fields v = reader.getTermVectors(0); - assertEquals(4, v.getUniqueFieldCount()); + assertEquals(4, v.size()); String[] expectedFields = new String[]{"a", "b", "c", "x"}; int[] expectedPositions = new int[]{1, 2, 0}; FieldsEnum fieldsEnum = v.iterator(); for(int i=0;i 0); + assertTrue(tfv.size() > 0); reader.close(); } diff --git a/solr/core/src/java/org/apache/solr/handler/admin/LukeRequestHandler.java b/solr/core/src/java/org/apache/solr/handler/admin/LukeRequestHandler.java index 9f254a81ced..6df7a214c86 100644 --- a/solr/core/src/java/org/apache/solr/handler/admin/LukeRequestHandler.java +++ b/solr/core/src/java/org/apache/solr/handler/admin/LukeRequestHandler.java @@ -595,7 +595,7 @@ public class LukeRequestHandler extends RequestHandlerBase if (freq > tiq.minFreq) { UnicodeUtil.UTF8toUTF16(text, spare); String t = spare.toString(); - tiq.distinctTerms = new Long(terms.getUniqueTermCount()).intValue(); + tiq.distinctTerms = new Long(terms.size()).intValue(); tiq.add(new TopTermQueue.TermInfo(new Term(field, t), termsEnum.docFreq())); if (tiq.size() > numTerms) { // if tiq full