LUCENE-1980: Fix javadocs after deprecation removal

git-svn-id: https://svn.apache.org/repos/asf/lucene/java/trunk@834704 13f79535-47bb-0310-9956-ffa450edef68

src/java/org/apache/lucene/document/NumericField.java

@@ -69,8 +69,7 @@ import org.apache.lucene.search.FieldCache; // javadocs
  * <code>NumericField</code>, use {@link NumericRangeQuery} or {@link
  * NumericRangeFilter}.  To sort according to a
  * <code>NumericField</code>, use the normal numeric sort types, eg
- * {@link SortField#INT} (note that {@link SortField#AUTO}
+ * {@link SortField#INT}. <code>NumericField</code> values
- * will not work with these fields).  <code>NumericField</code> values
  * can also be loaded directly from {@link FieldCache}.</p>
  *
  * <p>By default, a <code>NumericField</code>'s value is not stored but

src/java/org/apache/lucene/index/IndexDeletionPolicy.java

@@ -84,7 +84,7 @@ public interface IndexDeletionPolicy {
    * <p>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.
    *
    * <p><u>Note:</u> the last CommitPoint is the most recent one,
    * i.e. the "front index state". Be careful not to delete it,

src/java/org/apache/lucene/index/IndexReader.java

@@ -36,7 +36,7 @@ import java.util.Map;
 
  <p> Concrete subclasses of IndexReader are usually constructed with a call to
  one of the static <code>open()</code> methods, e.g. {@link
- #open(String, boolean)}.
+ #open(Directory, boolean)}.
 
  <p> For efficiency, in this API documents are often referred to via
  <i>document numbers</i>, 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

src/java/org/apache/lucene/index/IndexWriter.java

@@ -46,13 +46,13 @@ import java.util.Map;
   An <code>IndexWriter</code> creates and maintains an index.
 
   <p>The <code>create</code> 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 <code>create=true</code>
   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 <code>create</code> argument which will create a new index
   if there is not already an index at the provided path and otherwise 
   open the existing index.</p>

src/java/org/apache/lucene/search/BooleanQuery.java

@@ -118,13 +118,8 @@ public class BooleanQuery extends Query implements Iterable<BooleanClause> {
    * any specific clauses are required (or prohibited).  This number will
    * only be compared against the number of matching optional clauses.
    * </p>
-   * <p>
-   * EXPERT NOTE: Using this method may force collecting docs in order,
-   * regardless of whether setAllowDocsOutOfOrder(true) has been called.
-   * </p>
    *
    * @param min the number of optional clauses that must match
-   * @see #setAllowDocsOutOfOrder
    */
   public void setMinimumNumberShouldMatch(int min) {
     this.minNrShouldMatch = min;

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;
 

src/java/org/apache/lucene/search/MultiSearcher.java

@@ -35,8 +35,8 @@ import java.util.concurrent.locks.Lock;
 
 /** Implements search over a set of <code>Searchables</code>.
  *
- * <p>Applications usually need only call the inherited {@link #search(Query)}
+ * <p>Applications usually need only call the inherited {@link #search(Query,int)}
- * or {@link #search(Query,Filter)} methods.
+ * or {@link #search(Query,Filter,int)} methods.
  */
 public class MultiSearcher extends Searcher {
   

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 <code>Searchables</code>.
  *
- * <p>Applications usually need only call the inherited {@link #search(Query)}
+ * <p>Applications usually need only call the inherited {@link #search(Query,int)}
- * or {@link #search(Query,Filter)} methods.
+ * or {@link #search(Query,Filter,int)} methods.
  */
 public class ParallelMultiSearcher extends MultiSearcher {
   
@@ -131,7 +131,7 @@ public class ParallelMultiSearcher extends MultiSearcher {
   *
   * <p>Applications should only use this if they need <i>all</i> 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.
   * 
   * <p>This method cannot be parallelized, because {@link Collector}

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}.
    */

src/java/org/apache/lucene/search/Searchable.java

@@ -53,7 +53,7 @@ public interface Searchable extends Closeable {
    * 
    * <p>
    * Applications should only use this if they need <i>all</i> 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 <code>n</code>
    * hits for <code>query</code>, applying <code>filter</code> if non-null.
    *
-   * <p>Applications should usually call {@link Searcher#search(Query)} or
+   * <p>Applications should usually call {@link Searcher#search(Query,int)} or
-   * {@link Searcher#search(Query,Filter)} instead.
+   * {@link Searcher#search(Query,Filter,int)} instead.
    * @throws BooleanQuery.TooManyClauses
    */
   TopDocs search(Weight weight, Filter filter, int n) throws IOException;

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.
    *

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() {

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,int)} or {@link
-org.apache.lucene.search.Searcher#search(Query,Filter)}.
+org.apache.lucene.search.Searcher#search(Query,Filter,int)}.
 
     <!-- FILL IN MORE HERE -->   
 </p>

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.
  * <p/>
  * 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.
  * <p/>
  * Payload scores are aggregated using a pluggable {@link PayloadFunction}.
  * 
- * @see org.apache.lucene.search.Similarity#scorePayload(String, byte[], int,
+ * @see org.apache.lucene.search.Similarity#scorePayload
- *      int)
  */
 public class PayloadNearQuery extends SpanNearQuery {
   protected String fieldName;

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
+   *  directory.
-   *  filtering of the contents in a directory, and it will
+   * @throws IOException
-   *  never return null (throws IOException instead).
    */
   public abstract String[] listAll() throws IOException;
 

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.
  *

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.</p>