From 9ba4ce2ed5b2b2bc932b1f51f14428d0937458de Mon Sep 17 00:00:00 2001 From: Robert Muir Date: Wed, 12 Oct 2011 18:20:41 +0000 Subject: [PATCH] javadocs fixes git-svn-id: https://svn.apache.org/repos/asf/lucene/dev/trunk@1182505 13f79535-47bb-0310-9956-ffa450edef68 --- .../org/apache/lucene/document/FieldType.java | 2 +- .../org/apache/lucene/index/DocTermOrds.java | 2 +- .../apache/lucene/index/DocumentsWriter.java | 2 +- .../org/apache/lucene/index/IndexReader.java | 2 +- .../org/apache/lucene/index/IndexWriter.java | 2 +- .../apache/lucene/index/IndexableField.java | 18 +++++++++--------- .../lucene/index/IndexableFieldType.java | 16 ++++++++-------- .../apache/lucene/index/NoMergeScheduler.java | 2 +- .../PersistentSnapshotDeletionPolicy.java | 4 ++-- .../org/apache/lucene/index/SegmentInfo.java | 4 ++-- .../apache/lucene/index/TieredMergePolicy.java | 2 +- .../index/codecs/BlockTreeTermsReader.java | 2 +- .../index/codecs/memory/MemoryCodec.java | 2 +- .../org/apache/lucene/index/values/Bytes.java | 2 +- .../org/apache/lucene/store/RateLimiter.java | 4 ++-- .../java/org/apache/lucene/util/BytesRef.java | 2 +- .../lucene/util/automaton/BasicOperations.java | 2 +- .../util/fst/UpToTwoPositiveIntOutputs.java | 2 +- .../lucene/analysis/cjk/CJKAnalyzer.java | 2 +- .../analysis/hunspell/HunspellDictionary.java | 6 +++--- .../lucene/analysis/hunspell/HunspellWord.java | 2 +- .../lucene/analysis/synonym/SynonymFilter.java | 8 ++++---- .../lucene/analysis/synonym/SynonymMap.java | 4 ++-- .../CollatedTermAttributeImpl.java | 2 +- 24 files changed, 48 insertions(+), 48 deletions(-) diff --git a/lucene/src/java/org/apache/lucene/document/FieldType.java b/lucene/src/java/org/apache/lucene/document/FieldType.java index a219f82122c..d47d2f9d3a9 100644 --- a/lucene/src/java/org/apache/lucene/document/FieldType.java +++ b/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() { diff --git a/lucene/src/java/org/apache/lucene/index/DocTermOrds.java b/lucene/src/java/org/apache/lucene/index/DocTermOrds.java index 0b834ad4127..42d0b915393 100644 --- a/lucene/src/java/org/apache/lucene/index/DocTermOrds.java +++ b/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; diff --git a/lucene/src/java/org/apache/lucene/index/DocumentsWriter.java b/lucene/src/java/org/apache/lucene/index/DocumentsWriter.java index a63b430e542..e04e6598593 100644 --- a/lucene/src/java/org/apache/lucene/index/DocumentsWriter.java +++ b/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); } diff --git a/lucene/src/java/org/apache/lucene/index/IndexReader.java b/lucene/src/java/org/apache/lucene/index/IndexReader.java index 62d93008711..6d20ec7e06f 100644 --- a/lucene/src/java/org/apache/lucene/index/IndexReader.java +++ b/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.

diff --git a/lucene/src/java/org/apache/lucene/index/IndexWriter.java b/lucene/src/java/org/apache/lucene/index/IndexWriter.java index e8f7bdb8eb6..75688919666 100644 --- a/lucene/src/java/org/apache/lucene/index/IndexWriter.java +++ b/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(); diff --git a/lucene/src/java/org/apache/lucene/index/IndexableField.java b/lucene/src/java/org/apache/lucene/index/IndexableField.java index 1ee3f138276..22782a5582d 100644 --- a/lucene/src/java/org/apache/lucene/index/IndexableField.java +++ b/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(); /** diff --git a/lucene/src/java/org/apache/lucene/index/IndexableFieldType.java b/lucene/src/java/org/apache/lucene/index/IndexableFieldType.java index 2a8b51c1fd7..8821bee6db5 100644 --- a/lucene/src/java/org/apache/lucene/index/IndexableFieldType.java +++ b/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(); } diff --git a/lucene/src/java/org/apache/lucene/index/NoMergeScheduler.java b/lucene/src/java/org/apache/lucene/index/NoMergeScheduler.java index e98723b55b3..1f6fce7a9e7 100644 --- a/lucene/src/java/org/apache/lucene/index/NoMergeScheduler.java +++ b/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 diff --git a/lucene/src/java/org/apache/lucene/index/PersistentSnapshotDeletionPolicy.java b/lucene/src/java/org/apache/lucene/index/PersistentSnapshotDeletionPolicy.java index e7d594aa432..283365518eb 100644 --- a/lucene/src/java/org/apache/lucene/index/PersistentSnapshotDeletionPolicy.java +++ b/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. *

* NOTE: 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 { diff --git a/lucene/src/java/org/apache/lucene/index/SegmentInfo.java b/lucene/src/java/org/apache/lucene/index/SegmentInfo.java index ad87a91c86b..005672ee6a0 100644 --- a/lucene/src/java/org/apache/lucene/index/SegmentInfo.java +++ b/lucene/src/java/org/apache/lucene/index/SegmentInfo.java @@ -695,7 +695,7 @@ public final class SegmentInfo implements Cloneable { *

Current format looks like * _a(3.1):c45/4->_1, which means the segment's * name is _a; 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 C 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 diff --git a/lucene/src/java/org/apache/lucene/index/TieredMergePolicy.java b/lucene/src/java/org/apache/lucene/index/TieredMergePolicy.java index 3dd687b9c58..a2abf5454a3 100644 --- a/lucene/src/java/org/apache/lucene/index/TieredMergePolicy.java +++ b/lucene/src/java/org/apache/lucene/index/TieredMergePolicy.java @@ -39,7 +39,7 @@ import java.util.ArrayList; *

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), diff --git a/lucene/src/java/org/apache/lucene/index/codecs/BlockTreeTermsReader.java b/lucene/src/java/org/apache/lucene/index/codecs/BlockTreeTermsReader.java index fc66d1ee4b7..aa04ae2fab5 100644 --- a/lucene/src/java/org/apache/lucene/index/codecs/BlockTreeTermsReader.java +++ b/lucene/src/java/org/apache/lucene/index/codecs/BlockTreeTermsReader.java @@ -766,7 +766,7 @@ public class BlockTreeTermsReader extends FieldsProducer { arcs[arcIdx] = new FST.Arc(); } - // 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). diff --git a/lucene/src/java/org/apache/lucene/index/codecs/memory/MemoryCodec.java b/lucene/src/java/org/apache/lucene/index/codecs/memory/MemoryCodec.java index 8f6037815f3..0e797ab73a5 100644 --- a/lucene/src/java/org/apache/lucene/index/codecs/memory/MemoryCodec.java +++ b/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! * - *

NOTE: this codec cannot adress more than ~2.1 GB + *

NOTE: this codec cannot address more than ~2.1 GB * of postings, because the underlying FST uses an int * to address the underlying byte[]. * diff --git a/lucene/src/java/org/apache/lucene/index/values/Bytes.java b/lucene/src/java/org/apache/lucene/index/values/Bytes.java index b2f1ffda9e4..39e26ed3676 100644 --- a/lucene/src/java/org/apache/lucene/index/values/Bytes.java +++ b/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 diff --git a/lucene/src/java/org/apache/lucene/store/RateLimiter.java b/lucene/src/java/org/apache/lucene/store/RateLimiter.java index 30ed17b26e9..59ecbc23ca3 100644 --- a/lucene/src/java/org/apache/lucene/store/RateLimiter.java +++ b/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; diff --git a/lucene/src/java/org/apache/lucene/util/BytesRef.java b/lucene/src/java/org/apache/lucene/util/BytesRef.java index fe40d00d8b6..6473fba9639 100644 --- a/lucene/src/java/org/apache/lucene/util/BytesRef.java +++ b/lucene/src/java/org/apache/lucene/util/BytesRef.java @@ -79,7 +79,7 @@ public final class BytesRef implements Comparable { /** * @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) { diff --git a/lucene/src/java/org/apache/lucene/util/automaton/BasicOperations.java b/lucene/src/java/org/apache/lucene/util/automaton/BasicOperations.java index e7e9b301482..06713c6fc20 100644 --- a/lucene/src/java/org/apache/lucene/util/automaton/BasicOperations.java +++ b/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. */ diff --git a/lucene/src/java/org/apache/lucene/util/fst/UpToTwoPositiveIntOutputs.java b/lucene/src/java/org/apache/lucene/util/fst/UpToTwoPositiveIntOutputs.java index 4908301f99d..b05bdb32123 100644 --- a/lucene/src/java/org/apache/lucene/util/fst/UpToTwoPositiveIntOutputs.java +++ b/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")! diff --git a/modules/analysis/common/src/java/org/apache/lucene/analysis/cjk/CJKAnalyzer.java b/modules/analysis/common/src/java/org/apache/lucene/analysis/cjk/CJKAnalyzer.java index 7eafcd2d903..aa7f25a8943 100644 --- a/modules/analysis/common/src/java/org/apache/lucene/analysis/cjk/CJKAnalyzer.java +++ b/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. *

- * 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"; diff --git a/modules/analysis/common/src/java/org/apache/lucene/analysis/hunspell/HunspellDictionary.java b/modules/analysis/common/src/java/org/apache/lucene/analysis/hunspell/HunspellDictionary.java index 00e7afaf1be..6b5818558b8 100644 --- a/modules/analysis/common/src/java/org/apache/lucene/analysis/hunspell/HunspellDictionary.java +++ b/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); diff --git a/modules/analysis/common/src/java/org/apache/lucene/analysis/hunspell/HunspellWord.java b/modules/analysis/common/src/java/org/apache/lucene/analysis/hunspell/HunspellWord.java index 333bf1c34c3..fbb4ae93e12 100644 --- a/modules/analysis/common/src/java/org/apache/lucene/analysis/hunspell/HunspellWord.java +++ b/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; diff --git a/modules/analysis/common/src/java/org/apache/lucene/analysis/synonym/SynonymFilter.java b/modules/analysis/common/src/java/org/apache/lucene/analysis/synonym/SynonymFilter.java index 984298458d1..8821715d46a 100644 --- a/modules/analysis/common/src/java/org/apache/lucene/analysis/synonym/SynonymFilter.java +++ b/modules/analysis/common/src/java/org/apache/lucene/analysis/synonym/SynonymFilter.java @@ -65,13 +65,13 @@ import org.apache.lucene.util.fst.FST; *

NOTE: when a match occurs, the output tokens * associated with the matching rule are "stacked" on top of * the input stream (if the rule had - * keepOrig=true) and also on top of aother + * keepOrig=true) 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 PhraseQuery "y b * c" 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.

* @@ -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 diff --git a/modules/analysis/common/src/java/org/apache/lucene/analysis/synonym/SynonymMap.java b/modules/analysis/common/src/java/org/apache/lucene/analysis/synonym/SynonymMap.java index 12f7dd1e2ec..8b3b282ec02 100644 --- a/modules/analysis/common/src/java/org/apache/lucene/analysis/synonym/SynonymMap.java +++ b/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> */ + /** map<input word, list<ord>> */ public final FST fst; - /** map */ + /** map<ord, outputword> */ public final BytesRefHash words; /** maxHorizontalContext: maximum context we need on the tokenstream */ public final int maxHorizontalContext; diff --git a/modules/analysis/common/src/java/org/apache/lucene/collation/tokenattributes/CollatedTermAttributeImpl.java b/modules/analysis/common/src/java/org/apache/lucene/collation/tokenattributes/CollatedTermAttributeImpl.java index 68bb57bfa19..bda24896a22 100644 --- a/modules/analysis/common/src/java/org/apache/lucene/collation/tokenattributes/CollatedTermAttributeImpl.java +++ b/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(); }