diff --git a/src/java/org/apache/lucene/document/NumericField.java b/src/java/org/apache/lucene/document/NumericField.java index 5ce8f924f13..67530ebdd48 100644 --- a/src/java/org/apache/lucene/document/NumericField.java +++ b/src/java/org/apache/lucene/document/NumericField.java @@ -69,8 +69,7 @@ import org.apache.lucene.search.FieldCache; // javadocs * NumericField, use {@link NumericRangeQuery} or {@link * NumericRangeFilter}. To sort according to a * NumericField, use the normal numeric sort types, eg - * {@link SortField#INT} (note that {@link SortField#AUTO} - * will not work with these fields). NumericField values + * {@link SortField#INT}. NumericField values * can also be loaded directly from {@link FieldCache}.

* *

By default, a NumericField's value is not stored but diff --git a/src/java/org/apache/lucene/index/IndexDeletionPolicy.java b/src/java/org/apache/lucene/index/IndexDeletionPolicy.java index 1308d5f4c96..3005bae011d 100644 --- a/src/java/org/apache/lucene/index/IndexDeletionPolicy.java +++ b/src/java/org/apache/lucene/index/IndexDeletionPolicy.java @@ -84,7 +84,7 @@ public interface IndexDeletionPolicy { *

This method is only called when {@link * IndexWriter#commit} or {@link IndexWriter#close} is * called, or possibly not at all if the {@link - * IndexWriter#abort} is called. + * IndexWriter#rollback} is called. * *

Note: the last CommitPoint is the most recent one, * i.e. the "front index state". Be careful not to delete it, diff --git a/src/java/org/apache/lucene/index/IndexReader.java b/src/java/org/apache/lucene/index/IndexReader.java index 2d52a8e2bfe..6f643e7d7ec 100644 --- a/src/java/org/apache/lucene/index/IndexReader.java +++ b/src/java/org/apache/lucene/index/IndexReader.java @@ -36,7 +36,7 @@ import java.util.Map;

Concrete subclasses of IndexReader are usually constructed with a call to one of the static open() methods, e.g. {@link - #open(String, boolean)}. + #open(Directory, boolean)}.

For efficiency, in this API documents are often referred to via document numbers, non-negative integers which each name a unique @@ -1109,7 +1109,7 @@ public abstract class IndexReader implements Cloneable,Closeable { * one commit point. But if you're using a custom {@link * IndexDeletionPolicy} then there could be many commits. * Once you have a given commit, you can open a reader on - * it by calling {@link IndexReader#open(IndexCommit)} + * it by calling {@link IndexReader#open(IndexCommit,boolean)} * There must be at least one commit in * the Directory, else this method throws {@link * java.io.IOException}. Note that if a commit is in diff --git a/src/java/org/apache/lucene/index/IndexWriter.java b/src/java/org/apache/lucene/index/IndexWriter.java index 42cf24010db..4d0d7186cb8 100644 --- a/src/java/org/apache/lucene/index/IndexWriter.java +++ b/src/java/org/apache/lucene/index/IndexWriter.java @@ -46,13 +46,13 @@ import java.util.Map; An IndexWriter creates and maintains an index.

The create argument to the {@link - #IndexWriter(Directory, Analyzer, boolean) constructor} determines + #IndexWriter(Directory, Analyzer, boolean, MaxFieldLength) constructor} determines whether a new index is created, or whether an existing index is opened. Note that you can open an index with create=true even while readers are using the index. The old readers will continue to search the "point in time" snapshot they had opened, and won't see the newly created index until they re-open. There are - also {@link #IndexWriter(Directory, Analyzer) constructors} + also {@link #IndexWriter(Directory, Analyzer, MaxFieldLength) constructors} with no create argument which will create a new index if there is not already an index at the provided path and otherwise open the existing index.

diff --git a/src/java/org/apache/lucene/search/BooleanQuery.java b/src/java/org/apache/lucene/search/BooleanQuery.java index 5c7fe18e4e5..7abc57c5154 100644 --- a/src/java/org/apache/lucene/search/BooleanQuery.java +++ b/src/java/org/apache/lucene/search/BooleanQuery.java @@ -118,13 +118,8 @@ public class BooleanQuery extends Query implements Iterable { * any specific clauses are required (or prohibited). This number will * only be compared against the number of matching optional clauses. *

- *

- * EXPERT NOTE: Using this method may force collecting docs in order, - * regardless of whether setAllowDocsOutOfOrder(true) has been called. - *

* * @param min the number of optional clauses that must match - * @see #setAllowDocsOutOfOrder */ public void setMinimumNumberShouldMatch(int min) { this.minNrShouldMatch = min; diff --git a/src/java/org/apache/lucene/search/DocIdSetIterator.java b/src/java/org/apache/lucene/search/DocIdSetIterator.java index 0ab8dbe814c..7be02d535b7 100644 --- a/src/java/org/apache/lucene/search/DocIdSetIterator.java +++ b/src/java/org/apache/lucene/search/DocIdSetIterator.java @@ -32,7 +32,7 @@ public abstract class DocIdSetIterator { /** * When returned by {@link #nextDoc()}, {@link #advance(int)} and - * {@link #doc()} it means there are no more docs in the iterator. + * {@link #docID()} it means there are no more docs in the iterator. */ public static final int NO_MORE_DOCS = Integer.MAX_VALUE; diff --git a/src/java/org/apache/lucene/search/MultiSearcher.java b/src/java/org/apache/lucene/search/MultiSearcher.java index d73b7926bfd..9dba22bc51e 100644 --- a/src/java/org/apache/lucene/search/MultiSearcher.java +++ b/src/java/org/apache/lucene/search/MultiSearcher.java @@ -35,8 +35,8 @@ import java.util.concurrent.locks.Lock; /** Implements search over a set of Searchables. * - *

Applications usually need only call the inherited {@link #search(Query)} - * or {@link #search(Query,Filter)} methods. + *

Applications usually need only call the inherited {@link #search(Query,int)} + * or {@link #search(Query,Filter,int)} methods. */ public class MultiSearcher extends Searcher { diff --git a/src/java/org/apache/lucene/search/ParallelMultiSearcher.java b/src/java/org/apache/lucene/search/ParallelMultiSearcher.java index 4cd590aa037..ed8615a1422 100644 --- a/src/java/org/apache/lucene/search/ParallelMultiSearcher.java +++ b/src/java/org/apache/lucene/search/ParallelMultiSearcher.java @@ -36,8 +36,8 @@ import org.apache.lucene.util.PriorityQueue; /** Implements parallel search over a set of Searchables. * - *

Applications usually need only call the inherited {@link #search(Query)} - * or {@link #search(Query,Filter)} methods. + *

Applications usually need only call the inherited {@link #search(Query,int)} + * or {@link #search(Query,Filter,int)} methods. */ public class ParallelMultiSearcher extends MultiSearcher { @@ -131,7 +131,7 @@ public class ParallelMultiSearcher extends MultiSearcher { * *

Applications should only use this if they need all of the * matching documents. The high-level search API ({@link - * Searcher#search(Query)}) is usually more efficient, as it skips + * Searcher#search(Query,int)}) is usually more efficient, as it skips * non-high-scoring hits. * *

This method cannot be parallelized, because {@link Collector} diff --git a/src/java/org/apache/lucene/search/Scorer.java b/src/java/org/apache/lucene/search/Scorer.java index 5adee3f6ff5..3e04fe66117 100644 --- a/src/java/org/apache/lucene/search/Scorer.java +++ b/src/java/org/apache/lucene/search/Scorer.java @@ -36,8 +36,6 @@ import java.io.IOException; * not valid scores. Certain collectors (eg {@link * TopScoreDocCollector}) will not properly collect hits * with these scores. - * - * @see BooleanQuery#setAllowDocsOutOfOrder */ public abstract class Scorer extends DocIdSetIterator { private Similarity similarity; @@ -90,7 +88,7 @@ public abstract class Scorer extends DocIdSetIterator { } /** Returns the score of the current document matching the query. - * Initially invalid, until {@link #next()} or {@link #skipTo(int)} + * Initially invalid, until {@link #nextDoc()} or {@link #advance(int)} * is called the first time, or when called from within * {@link Collector#collect}. */ diff --git a/src/java/org/apache/lucene/search/Searchable.java b/src/java/org/apache/lucene/search/Searchable.java index 46c2ef3a56c..121b231af22 100644 --- a/src/java/org/apache/lucene/search/Searchable.java +++ b/src/java/org/apache/lucene/search/Searchable.java @@ -53,7 +53,7 @@ public interface Searchable extends Closeable { * *

* Applications should only use this if they need all of the matching - * documents. The high-level search API ({@link Searcher#search(Query)}) is + * documents. The high-level search API ({@link Searcher#search(Query,int)}) is * usually more efficient, as it skips non-high-scoring hits. * * @param weight @@ -93,8 +93,8 @@ public interface Searchable extends Closeable { /** Expert: Low-level search implementation. Finds the top n * hits for query, applying filter if non-null. * - *

Applications should usually call {@link Searcher#search(Query)} or - * {@link Searcher#search(Query,Filter)} instead. + *

Applications should usually call {@link Searcher#search(Query,int)} or + * {@link Searcher#search(Query,Filter,int)} instead. * @throws BooleanQuery.TooManyClauses */ TopDocs search(Weight weight, Filter filter, int n) throws IOException; diff --git a/src/java/org/apache/lucene/search/Similarity.java b/src/java/org/apache/lucene/search/Similarity.java index 56300d79958..376e0370c1b 100644 --- a/src/java/org/apache/lucene/search/Similarity.java +++ b/src/java/org/apache/lucene/search/Similarity.java @@ -660,7 +660,7 @@ public abstract class Similarity implements Serializable { /** Computes a score factor based on a term or phrase's frequency in a - * document. This value is multiplied by the {@link #idf(Term, Searcher)} + * document. This value is multiplied by the {@link #idf(int, int)} * factor for each term in the query and these products are then summed to * form the initial score for a document. * @@ -694,7 +694,7 @@ public abstract class Similarity implements Serializable { public abstract float sloppyFreq(int distance); /** Computes a score factor based on a term or phrase's frequency in a - * document. This value is multiplied by the {@link #idf(Term, Searcher)} + * document. This value is multiplied by the {@link #idf(int, int)} * factor for each term in the query and these products are then summed to * form the initial score for a document. * diff --git a/src/java/org/apache/lucene/search/Sort.java b/src/java/org/apache/lucene/search/Sort.java index f66cd5c1c13..9c2bd0e257d 100644 --- a/src/java/org/apache/lucene/search/Sort.java +++ b/src/java/org/apache/lucene/search/Sort.java @@ -103,7 +103,7 @@ implements Serializable { /** * Represents sorting by computed relevance. Using this sort criteria returns * the same results as calling - * {@link Searcher#search(Query) Searcher#search()}without a sort criteria, + * {@link Searcher#search(Query,int) Searcher#search()}without a sort criteria, * only with slightly more overhead. */ public static final Sort RELEVANCE = new Sort(); @@ -116,7 +116,7 @@ implements Serializable { /** * Sorts by computed relevance. This is the same sort criteria as calling - * {@link Searcher#search(Query) Searcher#search()}without a sort criteria, + * {@link Searcher#search(Query,int) Searcher#search()}without a sort criteria, * only with slightly more overhead. */ public Sort() { diff --git a/src/java/org/apache/lucene/search/package.html b/src/java/org/apache/lucene/search/package.html index 3eacd733f41..24b73216e08 100644 --- a/src/java/org/apache/lucene/search/package.html +++ b/src/java/org/apache/lucene/search/package.html @@ -36,8 +36,8 @@ Code to search indices. Search over indices. Applications usually call {@link -org.apache.lucene.search.Searcher#search(Query)} or {@link -org.apache.lucene.search.Searcher#search(Query,Filter)}. +org.apache.lucene.search.Searcher#search(Query,int)} or {@link +org.apache.lucene.search.Searcher#search(Query,Filter,int)}.

diff --git a/src/java/org/apache/lucene/search/payloads/PayloadNearQuery.java b/src/java/org/apache/lucene/search/payloads/PayloadNearQuery.java index b5027c52b1d..48c9e9f0668 100644 --- a/src/java/org/apache/lucene/search/payloads/PayloadNearQuery.java +++ b/src/java/org/apache/lucene/search/payloads/PayloadNearQuery.java @@ -43,13 +43,12 @@ import java.util.Iterator; * {@link org.apache.lucene.search.spans.TermSpans} occurs. *

* In order to take advantage of this, you must override - * {@link org.apache.lucene.search.Similarity#scorePayload(String, byte[],int,int)} + * {@link org.apache.lucene.search.Similarity#scorePayload} * which returns 1 by default. *

* Payload scores are aggregated using a pluggable {@link PayloadFunction}. * - * @see org.apache.lucene.search.Similarity#scorePayload(String, byte[], int, - * int) + * @see org.apache.lucene.search.Similarity#scorePayload */ public class PayloadNearQuery extends SpanNearQuery { protected String fieldName; diff --git a/src/java/org/apache/lucene/store/Directory.java b/src/java/org/apache/lucene/store/Directory.java index 026c3df8175..1e0b5047120 100644 --- a/src/java/org/apache/lucene/store/Directory.java +++ b/src/java/org/apache/lucene/store/Directory.java @@ -47,9 +47,8 @@ public abstract class Directory implements Closeable { protected LockFactory lockFactory; /** Returns an array of strings, one for each file in the - * directory. Unlike {@link #list} this method does no - * filtering of the contents in a directory, and it will - * never return null (throws IOException instead). + * directory. + * @throws IOException */ public abstract String[] listAll() throws IOException; diff --git a/src/java/org/apache/lucene/store/NoLockFactory.java b/src/java/org/apache/lucene/store/NoLockFactory.java index 32510ff4113..3406f6411ee 100755 --- a/src/java/org/apache/lucene/store/NoLockFactory.java +++ b/src/java/org/apache/lucene/store/NoLockFactory.java @@ -21,7 +21,6 @@ import java.io.IOException; /** * Use this {@link LockFactory} to disable locking entirely. - * This LockFactory is used when you call {@link FSDirectory#setDisableLocks}. * Only one instance of this lock is created. You should call {@link * #getNoLockFactory()} to get the instance. * diff --git a/src/java/org/apache/lucene/store/SimpleFSLockFactory.java b/src/java/org/apache/lucene/store/SimpleFSLockFactory.java index ab73f56a44d..fd6986374a8 100755 --- a/src/java/org/apache/lucene/store/SimpleFSLockFactory.java +++ b/src/java/org/apache/lucene/store/SimpleFSLockFactory.java @@ -38,7 +38,7 @@ import java.io.IOException; * is hit when trying to create a writer, in which case you * need to explicitly clear the lock file first. You can * either manually remove the file, or use the {@link - * org.apache.lucene.index.IndexReader#unlock(Directory)} + * org.apache.lucene.index.IndexWriter#unlock(Directory)} * API. But, first be certain that no writer is in fact * writing to the index otherwise you can easily corrupt * your index.