javadocs fixes

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

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

@@ -55,7 +55,7 @@ public class FieldType implements IndexableFieldType {
 
   /**
    * Prevents future changes. Note, it is recommended that this is called once
-   * the FieldTypes's properties have been set, to prevent unintential state
+   * the FieldTypes's properties have been set, to prevent unintentional state
    * changes.
    */
   public void freeze() {

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

@@ -101,7 +101,7 @@ import java.util.Comparator;
 
 public class DocTermOrds {
 
-  // Term ords are shifted by this, internally, to reseve
+  // Term ords are shifted by this, internally, to reserve
   // values 0 (end term) and 1 (index is a pointer into byte array)
   private final static int TNUM_OFFSET = 2;
 

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

@@ -411,7 +411,7 @@ final class DocumentsWriter {
          */
         try {
           synchronized (ticketQueue) {
-            // Each flush is assigned a ticket in the order they accquire the ticketQueue lock
+            // Each flush is assigned a ticket in the order they acquire the ticketQueue lock
             ticket =  new FlushTicket(flushingDWPT.prepareFlush(), true);
             ticketQueue.add(ticket);
           }

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

@@ -870,7 +870,7 @@ public abstract class IndexReader implements Cloneable,Closeable {
    * (ie, obtained by a call to {@link
    * IndexWriter#getReader}, or by calling {@link #openIfChanged}
    * on a near real-time reader), then this method checks if
-   * either a new commmit has occurred, or any new
+   * either a new commit has occurred, or any new
    * uncommitted changes have taken place via the writer.
    * Note that even if the writer has only performed
    * merging, this method will still return false.</p>

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

@@ -764,7 +764,7 @@ public class IndexWriter implements Closeable, TwoPhaseCommit {
       if (reader != null) {
         // the pulled reader could be from an in-flight merge 
         // while the info we see has already new applied deletes after a commit
-        // we max out the delets since deletes never shrink
+        // we max out the deletes since deletes never shrink
         return Math.max(info.getDelCount(), reader.numDeletedDocs());
       } else {
         return info.getDelCount();

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

@@ -40,7 +40,7 @@ public interface IndexableField {
 
   // TODO: add attrs to this API?
 
-  /* Field name */
+  /** Field name */
   public String name();
 
   // NOTE: if doc/field impl has the notion of "doc level boost"
@@ -49,24 +49,24 @@ public interface IndexableField {
   /** Field boost (you must pre-multiply in any doc boost). */
   public float boost();
   
-  /* Non-null if this field has a binary value */
+  /** Non-null if this field has a binary value */
   public BytesRef binaryValue();
 
-  /* Non-null if this field has a string value */
+  /** Non-null if this field has a string value */
   public String stringValue();
 
-  /* Non-null if this field has a Reader value */
+  /** Non-null if this field has a Reader value */
   public Reader readerValue();
 
   // Numeric field:
-  /* True if this field is numeric */
+  /** True if this field is numeric */
   public boolean numeric();
 
-  /* Numeric {@link NumericField.DataType}; only used if
+  /** Numeric {@link org.apache.lucene.document.NumericField.DataType}; only used if
    * the field is numeric */
   public NumericField.DataType numericDataType();
 
-  /* Numeric value; only used if the field is numeric */
+  /** Numeric value; only used if the field is numeric */
   public Number numericValue();
 
   /**
@@ -76,10 +76,10 @@ public interface IndexableField {
    */
   public IndexableFieldType fieldType();
   
-  /* Non-null if doc values should be indexed */
+  /** Non-null if doc values should be indexed */
   public PerDocFieldValues docValues();
 
-  /* DocValues type; only used if docValues is non-null */
+  /** DocValues type; only used if docValues is non-null */
   public ValueType docValuesType();
 
   /**

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

@@ -21,28 +21,28 @@ import org.apache.lucene.index.FieldInfo.IndexOptions;
 
 public interface IndexableFieldType {
 
-  /* True if this field should be indexed (inverted) */
+  /** True if this field should be indexed (inverted) */
   public boolean indexed();
 
-  /* True if the field's value should be stored */
+  /** True if the field's value should be stored */
   public boolean stored();
 
-  /* True if this field's value should be analyzed */
+  /** True if this field's value should be analyzed */
   public boolean tokenized();
 
-  /* True if term vectors should be indexed */
+  /** True if term vectors should be indexed */
   public boolean storeTermVectors();
 
-  /* True if term vector offsets should be indexed */
+  /** True if term vector offsets should be indexed */
   public boolean storeTermVectorOffsets();
 
-  /* True if term vector positions should be indexed */
+  /** True if term vector positions should be indexed */
   public boolean storeTermVectorPositions();
 
-  /* True if norms should not be indexed */
+  /** True if norms should not be indexed */
   public boolean omitNorms();
 
-  /* {@link IndexOptions}, describing what should be
+  /** {@link IndexOptions}, describing what should be
    * recorded into the inverted index */
   public IndexOptions indexOptions();
 }

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

@@ -23,7 +23,7 @@ import java.io.IOException;
  * A {@link MergeScheduler} which never executes any merges. It is also a
  * singleton and can be accessed through {@link NoMergeScheduler#INSTANCE}. Use
  * it if you want to prevent an {@link IndexWriter} from ever executing merges,
- * irregardless of the {@link MergePolicy} used. Note that you can achieve the
+ * regardless of the {@link MergePolicy} used. Note that you can achieve the
  * same thing by using {@link NoMergePolicy}, however with
  * {@link NoMergeScheduler} you also ensure that no unnecessary code of any
  * {@link MergeScheduler} implementation is ever executed. Hence it is

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

@@ -41,10 +41,10 @@ import org.apache.lucene.util.Version;
  * a Lucene index. It is highly recommended to use a dedicated directory (and on
  * stable storage as well) for persisting the snapshots' information, and not
  * reuse the content index directory, or otherwise conflicts and index
- * corruptions will occur.
+ * corruption will occur.
  * <p>
  * <b>NOTE:</b> you should call {@link #close()} when you're done using this
- * class for safetyness (it will close the {@link IndexWriter} instance used).
+ * class for safety (it will close the {@link IndexWriter} instance used).
  */
 public class PersistentSnapshotDeletionPolicy extends SnapshotDeletionPolicy {
 

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

@@ -695,7 +695,7 @@ public final class SegmentInfo implements Cloneable {
    *  <p>Current format looks like
    *  <code>_a(3.1):c45/4->_1</code>, which means the segment's
    *  name is <code>_a</code>; it was created with Lucene 3.1 (or
-   *  '?' if it's unkown); it's using compound file
+   *  '?' if it's unknown); it's using compound file
    *  format (would be <code>C</code> if not compound); it
    *  has 45 documents; it has 4 deletions (this part is
    *  left off when there are no deletions); it's using the
@@ -718,7 +718,7 @@ public final class SegmentInfo implements Cloneable {
       }
     } catch (Throwable e) {
       // Messy: because getHasVectors may be used in an
-      // un-thread-safe way, and may attempt to open an fnm
+      // thread-unsafe way, and may attempt to open an fnm
       // file that has since (legitimately) been deleted by
       // IndexWriter, instead of throwing these exceptions
       // up, just add v? to indicate we don't know if this

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

@@ -39,7 +39,7 @@ import java.util.ArrayList;
  *  <p>For normal merging, this policy first computes a
  *  "budget" of how many segments are allowed by be in the
  *  index.  If the index is over-budget, then the policy
- *  sorts segments by decresing size (pro-rating by percent
+ *  sorts segments by decreasing size (pro-rating by percent
  *  deletes), and then finds the least-cost merge.  Merge
  *  cost is measured by a combination of the "skew" of the
  *  merge (size of largest seg divided by smallest seg),

lucene/src/java/org/apache/lucene/index/codecs/BlockTreeTermsReader.java

@@ -766,7 +766,7 @@ public class BlockTreeTermsReader extends FieldsProducer {
           arcs[arcIdx] = new FST.Arc<BytesRef>();
         }
 
-        // TODO: if the automaon is "smallish" we really
+        // TODO: if the automaton is "smallish" we really
         // should use the terms index to seek at least to
         // the initial term and likely to subsequent terms
         // (or, maybe just fallback to ATE for such cases).

lucene/src/java/org/apache/lucene/index/codecs/memory/MemoryCodec.java

@@ -75,7 +75,7 @@ import org.apache.lucene.util.fst.FST;
  * queries that rely on advance will (AND BooleanQuery,
  * PhraseQuery) will be relatively slow!
  *
- * <p><b>NOTE</b>: this codec cannot adress more than ~2.1 GB
+ * <p><b>NOTE</b>: this codec cannot address more than ~2.1 GB
  * of postings, because the underlying FST uses an int
  * to address the underlying byte[].
  *

lucene/src/java/org/apache/lucene/index/values/Bytes.java

@@ -107,7 +107,7 @@ public final class Bytes {
    * @param bytesUsed
    *          an {@link AtomicLong} instance to track the used bytes within the
    *          {@link Writer}. A call to {@link Writer#finish(int)} will release
-   *          all internally used resources and frees the memeory tracking
+   *          all internally used resources and frees the memory tracking
    *          reference.
    * @param context 
    * @return a new {@link Writer} instance

lucene/src/java/org/apache/lucene/store/RateLimiter.java

@@ -63,7 +63,7 @@ public class RateLimiter {
    *  with a biggish count, not one byte at a time. */
   public void pause(long bytes) {
 
-    // TODO: this is purely instantenous rate; maybe we
+    // TODO: this is purely instantaneous rate; maybe we
     // should also offer decayed recent history one?
     final long targetNS = lastNS = lastNS + ((long) (bytes * nsPerByte));
     long curNS = System.nanoTime();
@@ -71,7 +71,7 @@ public class RateLimiter {
       lastNS = curNS;
     }
 
-    // While loop because Thread.sleep doesn't alway sleep
+    // While loop because Thread.sleep doesn't always sleep
     // enough:
     while(true) {
       final long pauseNS = targetNS - curNS;

lucene/src/java/org/apache/lucene/util/BytesRef.java

@@ -79,7 +79,7 @@ public final class BytesRef implements Comparable<BytesRef> {
 
   /**
    * @param text Initialize the byte[] from the UTF8 bytes
-   * for the provided Sring.  This must be well-formed
+   * for the provided String.  This must be well-formed
    * unicode text, with no unpaired surrogates or U+FFFF.
    */
   public BytesRef(CharSequence text) {

lucene/src/java/org/apache/lucene/util/automaton/BasicOperations.java

@@ -322,7 +322,7 @@ final public class BasicOperations {
     return c;
   }
 
-  /** Returns true if these two auotomata accept exactly the
+  /** Returns true if these two automata accept exactly the
    *  same language.  This is a costly computation!  Note
    *  also that a1 and a2 will be determinized as a side
    *  effect. */

lucene/src/java/org/apache/lucene/util/fst/UpToTwoPositiveIntOutputs.java

@@ -25,7 +25,7 @@ import org.apache.lucene.store.DataOutput;
 /**
  * Holds one or two longs for each input term.  If it's a
  * single output, Long is returned; else, TwoLongs.  Order
- * is preseved in the TwoLongs case, ie .first is the first
+ * is preserved in the TwoLongs case, ie .first is the first
  * input/output added to Builder, and .second is the
  * second.  You cannot store 0 output with this (that's
  * reserved to mean "no output")!

modules/analysis/common/src/java/org/apache/lucene/analysis/cjk/CJKAnalyzer.java

@@ -37,7 +37,7 @@ public final class CJKAnalyzer extends StopwordAnalyzerBase {
   /**
    * File containing default CJK stopwords.
    * <p/>
-   * Currently it concains some common English words that are not usually
+   * Currently it contains some common English words that are not usually
    * useful for searching and some double-byte interpunctions.
    */
   public final static String DEFAULT_STOPWORD_FILE = "stopwords.txt";

modules/analysis/common/src/java/org/apache/lucene/analysis/hunspell/HunspellDictionary.java

@@ -225,7 +225,7 @@ public class HunspellDictionary {
   }
 
   /**
-   * Parses the encoding specificed in the affix file readable through the provided InputStream
+   * Parses the encoding specified in the affix file readable through the provided InputStream
    *
    * @param affix InputStream for reading the affix file
    * @return Encoding specified in the affix file
@@ -277,10 +277,10 @@ public class HunspellDictionary {
   }
 
   /**
-   * Determines the appropriate {@link FlagParsingStrategy} based on the FLAG definiton line taken from the affix file
+   * Determines the appropriate {@link FlagParsingStrategy} based on the FLAG definition line taken from the affix file
    *
    * @param flagLine Line containing the flag information
-   * @return FlagParsingStrategy that handles parsing flags in the way specified in the FLAG definiton
+   * @return FlagParsingStrategy that handles parsing flags in the way specified in the FLAG definition
    */
   private FlagParsingStrategy getFlagParsingStrategy(String flagLine) {
     String flagType = flagLine.substring(5);

modules/analysis/common/src/java/org/apache/lucene/analysis/hunspell/HunspellWord.java

@@ -52,7 +52,7 @@ public class HunspellWord {
   /**
    * Returns the flags associated with the word
    *
-   * @return Flags asssociated with the word
+   * @return Flags associated with the word
    */
   public char[] getFlags() {
     return flags;

modules/analysis/common/src/java/org/apache/lucene/analysis/synonym/SynonymFilter.java

@@ -65,13 +65,13 @@ import org.apache.lucene.util.fst.FST;
  * <p><b>NOTE</b>: when a match occurs, the output tokens
  * associated with the matching rule are "stacked" on top of
  * the input stream (if the rule had
- * <code>keepOrig=true</code>) and also on top of aother
+ * <code>keepOrig=true</code>) and also on top of another
  * matched rule's output tokens.  This is not a correct
- * solution, as really the output should be an abitrary
+ * solution, as really the output should be an arbitrary
  * graph/lattice.  For example, with the above match, you
  * would expect an exact <code>PhraseQuery</code> <code>"y b
  * c"</code> to match the parsed tokens, but it will fail to
- * do so.  This limitations is necessary because Lucene's
+ * do so.  This limitation is necessary because Lucene's
  * TokenStream (and index) cannot yet represent an arbitrary
  * graph.</p>
  *
@@ -90,7 +90,7 @@ import org.apache.lucene.util.fst.FST;
 // http://en.wikipedia.org/wiki/Aho%E2%80%93Corasick_string_matching_algorithm
 // It improves over the current approach here
 // because it does not fully re-start matching at every
-// token.  For exampl,e if one pattern is "a b c x"
+// token.  For example if one pattern is "a b c x"
 // and another is "b c d" and the input is "a b c d", on
 // trying to parse "a b c x" but failing when you got to x,
 // rather than starting over again your really should

modules/analysis/common/src/java/org/apache/lucene/analysis/synonym/SynonymMap.java

@@ -44,9 +44,9 @@ import org.apache.lucene.util.fst.FST;
 public class SynonymMap {
   /** for multiword support, you must separate words with this separator */
   public static final char WORD_SEPARATOR = 0;
-  /** map<input word, list<ord>> */
+  /** map&lt;input word, list&lt;ord&gt;&gt; */
   public final FST<BytesRef> fst;
-  /** map<ord, outputword> */
+  /** map&lt;ord, outputword&gt; */
   public final BytesRefHash words;
   /** maxHorizontalContext: maximum context we need on the tokenstream */
   public final int maxHorizontalContext;

modules/analysis/common/src/java/org/apache/lucene/collation/tokenattributes/CollatedTermAttributeImpl.java

@@ -34,7 +34,7 @@ public class CollatedTermAttributeImpl extends CharTermAttributeImpl {
    * @param collator Collation key generator
    */
   public CollatedTermAttributeImpl(Collator collator) {
-    // clone in case JRE doesnt properly sync,
+    // clone in case JRE doesn't properly sync,
     // or to reduce contention in case they do
     this.collator = (Collator) collator.clone();
   }