Lucene.Net.Core.Index (Types starting with A-C): Fixed documentation comments
Project: http://git-wip-us.apache.org/repos/asf/lucenenet/repo Commit: http://git-wip-us.apache.org/repos/asf/lucenenet/commit/05c8b585 Tree: http://git-wip-us.apache.org/repos/asf/lucenenet/tree/05c8b585 Diff: http://git-wip-us.apache.org/repos/asf/lucenenet/diff/05c8b585 Branch: refs/heads/api-work Commit: 05c8b5851fa671e56996869488000418005c5f82 Parents: cce500f Author: Shad Storhaug <[email protected]> Authored: Thu Mar 30 23:43:50 2017 +0700 Committer: Shad Storhaug <[email protected]> Committed: Thu Mar 30 23:43:50 2017 +0700 ---------------------------------------------------------------------- src/Lucene.Net.Core/Index/AutomatonTermsEnum.cs | 59 +++---- .../Index/BaseCompositeReader.cs | 30 ++-- src/Lucene.Net.Core/Index/BinaryDocValues.cs | 2 +- .../Index/BinaryDocValuesFieldUpdates.cs | 6 +- .../Index/BinaryDocValuesWriter.cs | 4 +- src/Lucene.Net.Core/Index/BitsSlice.cs | 4 +- src/Lucene.Net.Core/Index/BufferedUpdates.cs | 20 ++- .../Index/BufferedUpdatesStream.cs | 49 +++--- src/Lucene.Net.Core/Index/ByteSliceReader.cs | 13 +- src/Lucene.Net.Core/Index/ByteSliceWriter.cs | 3 +- src/Lucene.Net.Core/Index/CheckIndex.cs | 164 ++++++++++--------- src/Lucene.Net.Core/Index/CompositeReader.cs | 45 +++-- .../Index/CompositeReaderContext.cs | 6 +- .../Index/ConcurrentMergeScheduler.cs | 97 +++++------ .../Index/CorruptIndexException.cs | 6 +- 15 files changed, 264 insertions(+), 244 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/lucenenet/blob/05c8b585/src/Lucene.Net.Core/Index/AutomatonTermsEnum.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Core/Index/AutomatonTermsEnum.cs b/src/Lucene.Net.Core/Index/AutomatonTermsEnum.cs index b6ba1b4..39b2458 100644 --- a/src/Lucene.Net.Core/Index/AutomatonTermsEnum.cs +++ b/src/Lucene.Net.Core/Index/AutomatonTermsEnum.cs @@ -29,20 +29,20 @@ namespace Lucene.Net.Index using Transition = Lucene.Net.Util.Automaton.Transition; /// <summary> - /// A FilteredTermsEnum that enumerates terms based upon what is accepted by a + /// A <see cref="FilteredTermsEnum"/> that enumerates terms based upon what is accepted by a /// DFA. - /// <p> + /// <para/> /// The algorithm is such: - /// <ol> - /// <li>As long as matches are successful, keep reading sequentially. - /// <li>When a match fails, skip to the next string in lexicographic order that - /// does not enter a reject state. - /// </ol> - /// <p> + /// <list type="number"> + /// <item>As long as matches are successful, keep reading sequentially.</item> + /// <item>When a match fails, skip to the next string in lexicographic order that + /// does not enter a reject state.</item> + /// </list> + /// <para> /// The algorithm does not attempt to actually skip to the next string that is /// completely accepted. this is not possible when the language accepted by the /// FSM is not finite (i.e. * operator). - /// </p> + /// </para> /// @lucene.experimental /// </summary> internal class AutomatonTermsEnum : FilteredTermsEnum @@ -79,10 +79,11 @@ namespace Lucene.Net.Index /// <summary> /// Construct an enumerator based upon an automaton, enumerating the specified - /// field, working on a supplied TermsEnum - /// <p> + /// field, working on a supplied <see cref="TermsEnum"/> + /// <para/> /// @lucene.experimental - /// <p> </summary> + /// </summary> + /// <param name="tenum"> TermsEnum </param> /// <param name="compiled"> CompiledAutomaton </param> public AutomatonTermsEnum(TermsEnum tenum, CompiledAutomaton compiled) : base(tenum) @@ -100,7 +101,7 @@ namespace Lucene.Net.Index } /// <summary> - /// Returns true if the term matches the automaton. Also stashes away the term + /// Returns <c>true</c> if the term matches the automaton. Also stashes away the term /// to assist with smart enumeration. /// </summary> protected override AcceptStatus Accept(BytesRef term) @@ -153,7 +154,7 @@ namespace Lucene.Net.Index /// <summary> /// Sets the enum to operate in linear fashion, as we have found /// a looping transition at position: we set an upper bound and - /// act like a TermRangeQuery for this portion of the term space. + /// act like a <see cref="Search.TermRangeQuery"/> for this portion of the term space. /// </summary> private void SetLinear(int position) { @@ -195,14 +196,14 @@ namespace Lucene.Net.Index private readonly Int32sRef savedStates = new Int32sRef(10); /// <summary> - /// Increments the byte buffer to the next String in binary order after s that will not put + /// Increments the byte buffer to the next string in binary order after s that will not put /// the machine into a reject state. If such a string does not exist, returns - /// false. - /// + /// <c>false</c>. + /// <para/> /// The correctness of this method depends upon the automaton being deterministic, /// and having no transitions to dead states. /// </summary> - /// <returns> true if more possible solutions exist for the DFA </returns> + /// <returns> <c>true</c> if more possible solutions exist for the DFA </returns> private bool NextString() { int state; @@ -263,21 +264,21 @@ namespace Lucene.Net.Index } /// <summary> - /// Returns the next String in lexicographic order that will not put + /// Returns the next string in lexicographic order that will not put /// the machine into a reject state. - /// - /// this method traverses the DFA from the given position in the String, + /// <para/> + /// This method traverses the DFA from the given position in the string, /// starting at the given state. - /// - /// If this cannot satisfy the machine, returns false. this method will + /// <para/> + /// If this cannot satisfy the machine, returns <c>false</c>. This method will /// walk the minimal path, in lexicographic order, as long as possible. - /// - /// If this method returns false, then there might still be more solutions, + /// <para/> + /// If this method returns <c>false</c>, then there might still be more solutions, /// it is necessary to backtrack to find out. /// </summary> /// <param name="state"> current non-reject state </param> /// <param name="position"> useful portion of the string </param> - /// <returns> true if more possible solutions exist for the DFA from this + /// <returns> <c>true</c> if more possible solutions exist for the DFA from this /// position </returns> private bool NextString(int state, int position) { @@ -350,11 +351,11 @@ namespace Lucene.Net.Index /// <summary> /// Attempts to backtrack thru the string after encountering a dead end - /// at some given position. Returns false if no more possible strings + /// at some given position. Returns <c>false</c> if no more possible strings /// can match. /// </summary> - /// <param name="position"> current position in the input String </param> - /// <returns> position >=0 if more possible solutions exist for the DFA </returns> + /// <param name="position"> current position in the input string </param> + /// <returns> position >=0 if more possible solutions exist for the DFA </returns> private int Backtrack(int position) { while (position-- > 0) http://git-wip-us.apache.org/repos/asf/lucenenet/blob/05c8b585/src/Lucene.Net.Core/Index/BaseCompositeReader.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Core/Index/BaseCompositeReader.cs b/src/Lucene.Net.Core/Index/BaseCompositeReader.cs index c33c3cf..90da6c8 100644 --- a/src/Lucene.Net.Core/Index/BaseCompositeReader.cs +++ b/src/Lucene.Net.Core/Index/BaseCompositeReader.cs @@ -22,29 +22,31 @@ namespace Lucene.Net.Index */ /// <summary> - /// Base class for implementing <seealso cref="CompositeReader"/>s based on an array + /// Base class for implementing <see cref="CompositeReader"/>s based on an array /// of sub-readers. The implementing class has to add code for /// correctly refcounting and closing the sub-readers. /// - /// <p>User code will most likely use <seealso cref="MultiReader"/> to build a + /// <para/>User code will most likely use <see cref="MultiReader"/> to build a /// composite reader on a set of sub-readers (like several - /// <seealso cref="DirectoryReader"/>s). + /// <see cref="DirectoryReader"/>s). /// - /// <p> For efficiency, in this API documents are often referred to via + /// <para/> For efficiency, in this API documents are often referred to via /// <i>document numbers</i>, non-negative integers which each name a unique /// document in the index. These document numbers are ephemeral -- they may change /// as documents are added to and deleted from an index. Clients should thus not /// rely on a given document having the same number between sessions. /// - /// <p><a name="thread-safety"></a><p><b>NOTE</b>: {@link - /// IndexReader} instances are completely thread + /// <para/><b>NOTE</b>: + /// <see cref="IndexReader"/> instances are completely thread /// safe, meaning multiple threads can call any of its methods, /// concurrently. If your application requires external /// synchronization, you should <b>not</b> synchronize on the - /// <code>IndexReader</code> instance; use your own - /// (non-Lucene) objects instead. </summary> - /// <seealso cref= MultiReader - /// @lucene.internal </seealso> + /// <see cref="IndexReader"/> instance; use your own + /// (non-Lucene) objects instead. + /// <para/> + /// @lucene.internal + /// </summary> + /// <seealso cref="MultiReader"/> public abstract class BaseCompositeReader<R> : CompositeReader where R : IndexReader { @@ -54,15 +56,15 @@ namespace Lucene.Net.Index private readonly int numDocs; /// <summary> - /// List view solely for <seealso cref="#getSequentialSubReaders()"/>, + /// List view solely for <see cref="GetSequentialSubReaders()"/>, /// for effectiveness the array is used internally. /// </summary> private readonly IList<R> subReadersList; /// <summary> - /// Constructs a {@code BaseCompositeReader} on the given subReaders. </summary> - /// <param name="subReaders"> the wrapped sub-readers. this array is returned by - /// <seealso cref="#getSequentialSubReaders"/> and used to resolve the correct + /// Constructs a <see cref="BaseCompositeReader{R}"/> on the given <paramref name="subReaders"/>. </summary> + /// <param name="subReaders"> the wrapped sub-readers. This array is returned by + /// <see cref="GetSequentialSubReaders()"/> and used to resolve the correct /// subreader for docID-based methods. <b>Please note:</b> this array is <b>not</b> /// cloned and not protected for modification, the subclass is responsible /// to do this. </param> http://git-wip-us.apache.org/repos/asf/lucenenet/blob/05c8b585/src/Lucene.Net.Core/Index/BinaryDocValues.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Core/Index/BinaryDocValues.cs b/src/Lucene.Net.Core/Index/BinaryDocValues.cs index 2c2ecbd..196ab7e 100644 --- a/src/Lucene.Net.Core/Index/BinaryDocValues.cs +++ b/src/Lucene.Net.Core/Index/BinaryDocValues.cs @@ -20,7 +20,7 @@ namespace Lucene.Net.Index using BytesRef = Lucene.Net.Util.BytesRef; /// <summary> - /// A per-document byte[] + /// A per-document <see cref="T:byte[]"/> /// </summary> public abstract class BinaryDocValues { http://git-wip-us.apache.org/repos/asf/lucenenet/blob/05c8b585/src/Lucene.Net.Core/Index/BinaryDocValuesFieldUpdates.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Core/Index/BinaryDocValuesFieldUpdates.cs b/src/Lucene.Net.Core/Index/BinaryDocValuesFieldUpdates.cs index d8648cf..43357b0 100644 --- a/src/Lucene.Net.Core/Index/BinaryDocValuesFieldUpdates.cs +++ b/src/Lucene.Net.Core/Index/BinaryDocValuesFieldUpdates.cs @@ -31,9 +31,9 @@ namespace Lucene.Net.Index using PagedMutable = Lucene.Net.Util.Packed.PagedMutable; /// <summary> - /// A <seealso cref="DocValuesFieldUpdates"/> which holds updates of documents, of a single - /// <seealso cref="BinaryDocValuesField"/>. - /// + /// A <see cref="DocValuesFieldUpdates"/> which holds updates of documents, of a single + /// <see cref="BinaryDocValuesField"/>. + /// <para/> /// @lucene.experimental /// </summary> internal class BinaryDocValuesFieldUpdates : DocValuesFieldUpdates http://git-wip-us.apache.org/repos/asf/lucenenet/blob/05c8b585/src/Lucene.Net.Core/Index/BinaryDocValuesWriter.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Core/Index/BinaryDocValuesWriter.cs b/src/Lucene.Net.Core/Index/BinaryDocValuesWriter.cs index 5c6be34..19c783e 100644 --- a/src/Lucene.Net.Core/Index/BinaryDocValuesWriter.cs +++ b/src/Lucene.Net.Core/Index/BinaryDocValuesWriter.cs @@ -33,8 +33,8 @@ namespace Lucene.Net.Index using RamUsageEstimator = Lucene.Net.Util.RamUsageEstimator; /// <summary> - /// Buffers up pending byte[] per doc, then flushes when - /// segment flushes. + /// Buffers up pending <see cref="T:byte[]"/> per doc, then flushes when + /// segment flushes. /// </summary> internal class BinaryDocValuesWriter : DocValuesWriter { http://git-wip-us.apache.org/repos/asf/lucenenet/blob/05c8b585/src/Lucene.Net.Core/Index/BitsSlice.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Core/Index/BitsSlice.cs b/src/Lucene.Net.Core/Index/BitsSlice.cs index 781ad34..91c8b24 100644 --- a/src/Lucene.Net.Core/Index/BitsSlice.cs +++ b/src/Lucene.Net.Core/Index/BitsSlice.cs @@ -23,8 +23,8 @@ namespace Lucene.Net.Index using IBits = Lucene.Net.Util.IBits; /// <summary> - /// Exposes a slice of an existing Bits as a new Bits. - /// + /// Exposes a slice of an existing <see cref="IBits"/> as a new <see cref="IBits"/>. + /// <para/> /// @lucene.internal /// </summary> internal sealed class BitsSlice : IBits http://git-wip-us.apache.org/repos/asf/lucenenet/blob/05c8b585/src/Lucene.Net.Core/Index/BufferedUpdates.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Core/Index/BufferedUpdates.cs b/src/Lucene.Net.Core/Index/BufferedUpdates.cs index a069fb4..cdc5ff4 100644 --- a/src/Lucene.Net.Core/Index/BufferedUpdates.cs +++ b/src/Lucene.Net.Core/Index/BufferedUpdates.cs @@ -27,16 +27,18 @@ namespace Lucene.Net.Index using Query = Lucene.Net.Search.Query; using RamUsageEstimator = Lucene.Net.Util.RamUsageEstimator; - /* Holds buffered deletes and updates, by docID, term or query for a - * single segment. this is used to hold buffered pending - * deletes and updates against the to-be-flushed segment. Once the - * deletes and updates are pushed (on flush in DocumentsWriter), they - * are converted to a FrozenDeletes instance. */ - - // NOTE: instances of this class are accessed either via a private - // instance on DocumentWriterPerThread, or via sync'd code by - // DocumentsWriterDeleteQueue + /// <summary> + /// Holds buffered deletes and updates, by docID, term or query for a + /// single segment. this is used to hold buffered pending + /// deletes and updates against the to-be-flushed segment. Once the + /// deletes and updates are pushed (on flush in <see cref="DocumentsWriter"/>), they + /// are converted to a FrozenDeletes instance. + /// <para/> + /// NOTE: instances of this class are accessed either via a private + /// instance on <see cref="DocumentsWriterPerThread"/>, or via sync'd code by + /// <see cref="DocumentsWriterDeleteQueue"/> + /// </summary> public class BufferedUpdates // LUCENENET NOTE: Made public rather than internal because it is available through a public API { /* Rough logic: HashMap has an array[Entry] w/ varying http://git-wip-us.apache.org/repos/asf/lucenenet/blob/05c8b585/src/Lucene.Net.Core/Index/BufferedUpdatesStream.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Core/Index/BufferedUpdatesStream.cs b/src/Lucene.Net.Core/Index/BufferedUpdatesStream.cs index 4aad5f3..ffce501 100644 --- a/src/Lucene.Net.Core/Index/BufferedUpdatesStream.cs +++ b/src/Lucene.Net.Core/Index/BufferedUpdatesStream.cs @@ -30,21 +30,22 @@ namespace Lucene.Net.Index using Query = Lucene.Net.Search.Query; using QueryWrapperFilter = Lucene.Net.Search.QueryWrapperFilter; - /* Tracks the stream of {@link BufferedDeletes}. - * When DocumentsWriterPerThread flushes, its buffered - * deletes and updates are appended to this stream. We later - * apply them (resolve them to the actual - * docIDs, per segment) when a merge is started - * (only to the to-be-merged segments). We - * also apply to all segments when NRT reader is pulled, - * commit/close is called, or when too many deletes or updates are - * buffered and must be flushed (by RAM usage or by count). - * - * Each packet is assigned a generation, and each flushed or - * merged segment is also assigned a generation, so we can - * track which BufferedDeletes packets to apply to any given - * segment. */ - + /// <summary> + /// Tracks the stream of BufferedDeletes. + /// When <see cref="DocumentsWriterPerThread"/> flushes, its buffered + /// deletes and updates are appended to this stream. We later + /// apply them (resolve them to the actual + /// docIDs, per segment) when a merge is started + /// (only to the to-be-merged segments). We + /// also apply to all segments when NRT reader is pulled, + /// commit/close is called, or when too many deletes or updates are + /// buffered and must be flushed (by RAM usage or by count). + /// <para/> + /// Each packet is assigned a generation, and each flushed or + /// merged segment is also assigned a generation, so we can + /// track which BufferedDeletes packets to apply to any given + /// segment. + /// </summary> internal class BufferedUpdatesStream { // TODO: maybe linked list? @@ -67,8 +68,10 @@ namespace Lucene.Net.Index this.infoStream = infoStream; } - // Appends a new packet of buffered deletes to the stream, - // setting its generation: + /// <summary> + /// Appends a new packet of buffered deletes to the stream, + /// setting its generation: + /// </summary> public virtual long Push(FrozenBufferedUpdates packet) { lock (this) @@ -171,8 +174,8 @@ namespace Lucene.Net.Index /// <summary> /// Resolves the buffered deleted Term/Query/docIDs, into - /// actual deleted docIDs in the liveDocs MutableBits for - /// each SegmentReader. + /// actual deleted docIDs in the liveDocs <see cref="Util.IMutableBits"/> for + /// each <see cref="SegmentReader"/>. /// </summary> public virtual ApplyDeletesResult ApplyDeletesAndUpdates(IndexWriter.ReaderPool readerPool, IList<SegmentCommitInfo> infos) { @@ -389,10 +392,12 @@ namespace Lucene.Net.Index } // Lock order IW -> BD - /* Removes any BufferedDeletes that we no longer need to - * store because all segments in the index have had the - * deletes applied. */ + /// <summary> + /// Removes any BufferedDeletes that we no longer need to + /// store because all segments in the index have had the + /// deletes applied. + /// </summary> public virtual void Prune(SegmentInfos segmentInfos) { lock (this) http://git-wip-us.apache.org/repos/asf/lucenenet/blob/05c8b585/src/Lucene.Net.Core/Index/ByteSliceReader.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Core/Index/ByteSliceReader.cs b/src/Lucene.Net.Core/Index/ByteSliceReader.cs index f0ba110..47061ec 100644 --- a/src/Lucene.Net.Core/Index/ByteSliceReader.cs +++ b/src/Lucene.Net.Core/Index/ByteSliceReader.cs @@ -24,12 +24,13 @@ namespace Lucene.Net.Index using DataInput = Lucene.Net.Store.DataInput; using DataOutput = Lucene.Net.Store.DataOutput; - /* IndexInput that knows how to read the byte slices written - * by Posting and PostingVector. We read the bytes in - * each slice until we hit the end of that slice at which - * point we read the forwarding address of the next slice - * and then jump to it.*/ - + /// <summary> + /// <see cref="Store.IndexInput"/> that knows how to read the byte slices written + /// by Posting and PostingVector. We read the bytes in + /// each slice until we hit the end of that slice at which + /// point we read the forwarding address of the next slice + /// and then jump to it. + /// </summary> public sealed class ByteSliceReader : DataInput // LUCENENET specific - changed from internal to public because returned from public API { private ByteBlockPool pool; http://git-wip-us.apache.org/repos/asf/lucenenet/blob/05c8b585/src/Lucene.Net.Core/Index/ByteSliceWriter.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Core/Index/ByteSliceWriter.cs b/src/Lucene.Net.Core/Index/ByteSliceWriter.cs index e7b65be..f9fe770 100644 --- a/src/Lucene.Net.Core/Index/ByteSliceWriter.cs +++ b/src/Lucene.Net.Core/Index/ByteSliceWriter.cs @@ -24,10 +24,9 @@ namespace Lucene.Net.Index /// <summary> /// Class to write byte streams into slices of shared - /// byte[]. this is used by DocumentsWriter to hold the + /// <see cref="T:byte[]"/>. This is used by <see cref="DocumentsWriter"/> to hold the /// posting list for many terms in RAM. /// </summary> - internal sealed class ByteSliceWriter : DataOutput { private byte[] slice; http://git-wip-us.apache.org/repos/asf/lucenenet/blob/05c8b585/src/Lucene.Net.Core/Index/CheckIndex.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Core/Index/CheckIndex.cs b/src/Lucene.Net.Core/Index/CheckIndex.cs index 84657e1..4356273 100644 --- a/src/Lucene.Net.Core/Index/CheckIndex.cs +++ b/src/Lucene.Net.Core/Index/CheckIndex.cs @@ -45,11 +45,14 @@ namespace Lucene.Net.Index /// write a new segments file that removes reference to /// problematic segments. /// - /// <p>As this tool checks every byte in the index, on a large + /// <para/>As this tool checks every byte in the index, on a large /// index it can take quite a long time to run. /// - /// @lucene.experimental Please make a complete backup of your + /// <para/> + /// Please make a complete backup of your /// index before using this to fix your index! + /// <para/> + /// @lucene.experimental /// </summary> public class CheckIndex { @@ -57,12 +60,10 @@ namespace Lucene.Net.Index private Directory dir; /// <summary> - /// Returned from <seealso cref="#checkIndex()"/> detailing the health and status of the index. - /// + /// Returned from <see cref="CheckIndex.DoCheckIndex()"/> detailing the health and status of the index. + /// <para/> /// @lucene.experimental - /// /// </summary> - public class Status { internal Status() @@ -88,9 +89,9 @@ namespace Lucene.Net.Index /// True if we were unable to read the version number from segments_N file. </summary> public bool MissingSegmentVersion { get; internal set; } // LUCENENET specific - made setter internal - /// <summary> - /// Name of latest segments_N file in the index. </summary> - public string SegmentsFileName { get; internal set; } // LUCENENET specific - made setter internal + /// <summary> + /// Name of latest segments_N file in the index. </summary> + public string SegmentsFileName { get; internal set; } // LUCENENET specific - made setter internal /// <summary> /// Number of segments in the index. </summary> @@ -98,24 +99,24 @@ namespace Lucene.Net.Index /// <summary> /// Empty unless you passed specific segments list to check as optional 3rd argument. </summary> - /// <seealso cref= CheckIndex#checkIndex(List) </seealso> + /// <seealso cref="CheckIndex.DoCheckIndex(IList{string})"/> public IList<string> SegmentsChecked { get; internal set; } // LUCENENET specific - made setter internal /// <summary> - /// True if the index was created with a newer version of Lucene than the CheckIndex tool. </summary> + /// True if the index was created with a newer version of Lucene than the <see cref="CheckIndex"/> tool. </summary> public bool ToolOutOfDate { get; internal set; } // LUCENENET specific - made setter internal /// <summary> - /// List of <seealso cref="SegmentInfoStatus"/> instances, detailing status of each segment. </summary> + /// List of <see cref="SegmentInfoStatus"/> instances, detailing status of each segment. </summary> public IList<SegmentInfoStatus> SegmentInfos { get; internal set; } // LUCENENET specific - made setter internal /// <summary> - /// Directory index is in. </summary> + /// <see cref="Directory"/> index is in. </summary> public Directory Dir { get; internal set; } // LUCENENET specific - made setter internal /// <summary> - /// SegmentInfos instance containing only segments that - /// had no problems (this is used with the <seealso cref="CheckIndex#fixIndex"/> + /// <see cref="Index.SegmentInfos"/> instance containing only segments that + /// had no problems (this is used with the <see cref="CheckIndex.FixIndex(Status)"/> /// method to repair the index. /// </summary> internal SegmentInfos NewSegments { get; set; } @@ -129,8 +130,8 @@ namespace Lucene.Net.Index public int NumBadSegments { get; internal set; } // LUCENENET specific - made setter internal /// <summary> - /// True if we checked only specific segments ({@link - /// #checkIndex(List)}) was called with non-null + /// True if we checked only specific segments + /// (<see cref="DoCheckIndex(IList{string})"/> was called with non-null /// argument). /// </summary> public bool Partial { get; internal set; } // LUCENENET specific - made setter internal @@ -140,7 +141,7 @@ namespace Lucene.Net.Index public int MaxSegmentName { get; internal set; } // LUCENENET specific - made setter internal /// <summary> - /// Whether the SegmentInfos.counter is greater than any of the segments' names. </summary> + /// Whether the <see cref="SegmentInfos.Counter"/> is greater than any of the segments' names. </summary> public bool ValidCounter { get; internal set; } // LUCENENET specific - made setter internal /// <summary> @@ -149,8 +150,8 @@ namespace Lucene.Net.Index /// <summary> /// Holds the status of each segment in the index. - /// See <seealso cref="#segmentInfos"/>. - /// + /// See <see cref="SegmentInfos"/>. + /// <para/> /// @lucene.experimental /// </summary> public class SegmentInfoStatus @@ -183,26 +184,26 @@ namespace Lucene.Net.Index /// <summary> /// Net size (MB) of the files referenced by this - /// segment. + /// segment. /// </summary> public double SizeMB { get; internal set; } // LUCENENET specific - made setter internal /// <summary> /// Doc store offset, if this segment shares the doc - /// store files (stored fields and term vectors) with - /// other segments. this is -1 if it does not share. + /// store files (stored fields and term vectors) with + /// other segments. This is -1 if it does not share. /// </summary> public int DocStoreOffset { get; internal set; } // LUCENENET specific - made setter internal /// <summary> - /// String of the shared doc store segment, or null if - /// this segment does not share the doc store files. + /// String of the shared doc store segment, or <c>null</c> if + /// this segment does not share the doc store files. /// </summary> public string DocStoreSegment { get; internal set; } // LUCENENET specific - made setter internal /// <summary> /// True if the shared doc store files are compound file - /// format. + /// format. /// </summary> public bool DocStoreCompoundFile { get; internal set; } // LUCENENET specific - made setter internal @@ -219,8 +220,8 @@ namespace Lucene.Net.Index public int NumDeleted { get; internal set; } // LUCENENET specific - made setter internal /// <summary> - /// True if we were able to open an AtomicReader on this - /// segment. + /// True if we were able to open an <see cref="AtomicReader"/> on this + /// segment. /// </summary> public bool OpenReaderPassed { get; internal set; } // LUCENENET specific - made setter internal @@ -230,29 +231,29 @@ namespace Lucene.Net.Index /// <summary> /// Map that includes certain - /// debugging details that IndexWriter records into - /// each segment it creates + /// debugging details that <see cref="IndexWriter"/> records into + /// each segment it creates /// </summary> public IDictionary<string, string> Diagnostics { get; internal set; } // LUCENENET specific - made setter internal /// <summary> - /// Status for testing of field norms (null if field norms could not be tested). </summary> + /// Status for testing of field norms (<c>null</c> if field norms could not be tested). </summary> public FieldNormStatus FieldNormStatus { get; internal set; } // LUCENENET specific - made setter internal /// <summary> - /// Status for testing of indexed terms (null if indexed terms could not be tested). </summary> + /// Status for testing of indexed terms (<c>null</c> if indexed terms could not be tested). </summary> public TermIndexStatus TermIndexStatus { get; internal set; } // LUCENENET specific - made setter internal /// <summary> - /// Status for testing of stored fields (null if stored fields could not be tested). </summary> + /// Status for testing of stored fields (<c>null</c> if stored fields could not be tested). </summary> public StoredFieldStatus StoredFieldStatus { get; internal set; } // LUCENENET specific - made setter internal /// <summary> - /// Status for testing of term vectors (null if term vectors could not be tested). </summary> + /// Status for testing of term vectors (<c>null</c> if term vectors could not be tested). </summary> public TermVectorStatus TermVectorStatus { get; internal set; } // LUCENENET specific - made setter internal /// <summary> - /// Status for testing of DocValues (null if DocValues could not be tested). </summary> + /// Status for testing of <see cref="DocValues"/> (<c>null</c> if <see cref="DocValues"/> could not be tested). </summary> public DocValuesStatus DocValuesStatus { get; internal set; } // LUCENENET specific - made setter internal } @@ -273,7 +274,7 @@ namespace Lucene.Net.Index public long TotFields { get; internal set; } // LUCENENET specific - made setter internal /// <summary> - /// Exception thrown during term index test (null on success) </summary> + /// Exception thrown during term index test (<c>null</c> on success) </summary> public Exception Error { get; internal set; } // LUCENENET specific - made setter internal } @@ -310,14 +311,14 @@ namespace Lucene.Net.Index public long TotPos { get; internal set; } // LUCENENET specific - made setter internal /// <summary> - /// Exception thrown during term index test (null on success) </summary> + /// Exception thrown during term index test (<c>null</c> on success) </summary> public Exception Error { get; internal set; } // LUCENENET specific - made setter internal /// <summary> /// Holds details of block allocations in the block - /// tree terms dictionary (this is only set if the - /// <seealso cref="PostingsFormat"/> for this segment uses block - /// tree. + /// tree terms dictionary (this is only set if the + /// <see cref="PostingsFormat"/> for this segment uses block + /// tree. /// </summary> public IDictionary<string, BlockTreeTermsReader.Stats> BlockTreeStats { get; internal set; } // LUCENENET specific - made setter internal } @@ -344,7 +345,7 @@ namespace Lucene.Net.Index public long TotFields { get; internal set; } // LUCENENET specific - made setter internal /// <summary> - /// Exception thrown during stored fields test (null on success) </summary> + /// Exception thrown during stored fields test (<c>null</c> on success) </summary> public Exception Error { get; internal set; } // LUCENENET specific - made setter internal } @@ -370,12 +371,12 @@ namespace Lucene.Net.Index public long TotVectors { get; internal set; } // LUCENENET specific - made setter internal /// <summary> - /// Exception thrown during term vector test (null on success) </summary> + /// Exception thrown during term vector test (<c>null</c> on success) </summary> public Exception Error { get; internal set; } // LUCENENET specific - made setter internal } /// <summary> - /// Status from testing DocValues + /// Status from testing <see cref="DocValues"/> /// </summary> public sealed class DocValuesStatus { @@ -406,13 +407,13 @@ namespace Lucene.Net.Index public long TotalSortedSetFields { get; internal set; } // LUCENENET specific - made setter internal /// <summary> - /// Exception thrown during doc values test (null on success) </summary> + /// Exception thrown during doc values test (<c>null</c> on success) </summary> public Exception Error { get; internal set; } // LUCENENET specific - made setter internal } } /// <summary> - /// Create a new CheckIndex on the directory. </summary> + /// Create a new <see cref="CheckIndex"/> on the directory. </summary> public CheckIndex(Directory dir) { this.dir = dir; @@ -422,9 +423,9 @@ namespace Lucene.Net.Index private bool crossCheckTermVectors; /// <summary> - /// If true, term vectors are compared against postings to - /// make sure they are the same. this will likely - /// drastically increase time it takes to run CheckIndex! + /// If <c>true</c>, term vectors are compared against postings to + /// make sure they are the same. This will likely + /// drastically increase time it takes to run <see cref="CheckIndex"/>! /// </summary> public virtual bool CrossCheckTermVectors { @@ -443,7 +444,7 @@ namespace Lucene.Net.Index // LUCENENET specific - added getter so we don't need to keep a reference outside of this class to dispose /// <summary> /// Gets or Sets infoStream where messages should go. If null, no - /// messages are printed. If <see cref="InfoStreamIsVerbose"/> is true then more + /// messages are printed. If <see cref="InfoStreamIsVerbose"/> is <c>true</c> then more /// details are printed. /// </summary> public virtual TextWriter InfoStream @@ -461,7 +462,7 @@ namespace Lucene.Net.Index } /// <summary> - /// If true, prints more details to the <see cref="InfoStream"/>, if set. + /// If <c>true</c>, prints more details to the <see cref="InfoStream"/>, if set. /// </summary> public virtual bool InfoStreamIsVerbose // LUCENENET specific (replaced overload of SetInfoStream with property) { @@ -483,15 +484,15 @@ namespace Lucene.Net.Index } /// <summary> - /// Returns a <seealso cref="Status"/> instance detailing - /// the state of the index. + /// Returns a <see cref="Status"/> instance detailing + /// the state of the index. /// - /// <p>As this method checks every byte in the index, on a large - /// index it can take quite a long time to run. + /// <para/>As this method checks every byte in the index, on a large + /// index it can take quite a long time to run. /// - /// <p><b>WARNING</b>: make sure - /// you only call this when the index is not opened by any - /// writer. + /// <para/><b>WARNING</b>: make sure + /// you only call this when the index is not opened by any + /// writer. /// </summary> public virtual Status DoCheckIndex() { @@ -499,18 +500,18 @@ namespace Lucene.Net.Index } /// <summary> - /// Returns a <seealso cref="Status"/> instance detailing - /// the state of the index. + /// Returns a <see cref="Status"/> instance detailing + /// the state of the index. /// </summary> - /// <param name="onlySegments"> list of specific segment names to check + /// <param name="onlySegments"> list of specific segment names to check /// - /// <p>As this method checks every byte in the specified - /// segments, on a large index it can take quite a long - /// time to run. + /// <para/>As this method checks every byte in the specified + /// segments, on a large index it can take quite a long + /// time to run. /// - /// <p><b>WARNING</b>: make sure - /// you only call this when the index is not opened by any - /// writer. </param> + /// <para/><b>WARNING</b>: make sure + /// you only call this when the index is not opened by any + /// writer. </param> public virtual Status DoCheckIndex(IList<string> onlySegments) { NumberFormatInfo nf = CultureInfo.CurrentCulture.NumberFormat; @@ -933,6 +934,7 @@ namespace Lucene.Net.Index /// <summary> /// Test field norms. + /// <para/> /// @lucene.experimental /// </summary> public static Status.FieldNormStatus TestFieldNorms(AtomicReader reader, TextWriter infoStream) @@ -988,8 +990,8 @@ namespace Lucene.Net.Index } /// <summary> - /// checks Fields api is consistent with itself. - /// searcher is optional, to verify with queries. Can be null. + /// Checks <see cref="Fields"/> api is consistent with itself. + /// Searcher is optional, to verify with queries. Can be <c>null</c>. /// </summary> private static Status.TermIndexStatus CheckFields(Fields fields, IBits liveDocs, int maxDoc, FieldInfos fieldInfos, bool doPrint, bool isVectors, TextWriter infoStream, bool verbose) { @@ -1644,6 +1646,7 @@ namespace Lucene.Net.Index /// <summary> /// Test the term index. + /// <para/> /// @lucene.experimental /// </summary> public static Status.TermIndexStatus TestPostings(AtomicReader reader, TextWriter infoStream) @@ -1653,6 +1656,7 @@ namespace Lucene.Net.Index /// <summary> /// Test the term index. + /// <para/> /// @lucene.experimental /// </summary> public static Status.TermIndexStatus TestPostings(AtomicReader reader, TextWriter infoStream, bool verbose) @@ -1703,6 +1707,7 @@ namespace Lucene.Net.Index /// <summary> /// Test stored fields. + /// <para/> /// @lucene.experimental /// </summary> public static Status.StoredFieldStatus TestStoredFields(AtomicReader reader, TextWriter infoStream) @@ -1757,6 +1762,7 @@ namespace Lucene.Net.Index /// <summary> /// Test docvalues. + /// <para/> /// @lucene.experimental /// </summary> public static Status.DocValuesStatus TestDocValues(AtomicReader reader, TextWriter infoStream) @@ -2044,6 +2050,7 @@ namespace Lucene.Net.Index /// <summary> /// Test term vectors. + /// <para/> /// @lucene.experimental /// </summary> public static Status.TermVectorStatus TestTermVectors(AtomicReader reader, TextWriter infoStream) @@ -2053,6 +2060,7 @@ namespace Lucene.Net.Index /// <summary> /// Test term vectors. + /// <para/> /// @lucene.experimental /// </summary> public static Status.TermVectorStatus TestTermVectors(AtomicReader reader, TextWriter infoStream, bool verbose, bool crossCheckTermVectors) @@ -2329,18 +2337,18 @@ namespace Lucene.Net.Index /// <summary> /// Repairs the index using previously returned result - /// from <seealso cref="#checkIndex"/>. Note that this does not - /// remove any of the unreferenced files after it's done; - /// you must separately open an <seealso cref="IndexWriter"/>, which - /// deletes unreferenced files when it's created. + /// from <see cref="DoCheckIndex()"/>. Note that this does not + /// remove any of the unreferenced files after it's done; + /// you must separately open an <see cref="IndexWriter"/>, which + /// deletes unreferenced files when it's created. /// - /// <p><b>WARNING</b>: this writes a - /// new segments file into the index, effectively removing - /// all documents in broken segments from the index. - /// BE CAREFUL. + /// <para/><b>WARNING</b>: this writes a + /// new segments file into the index, effectively removing + /// all documents in broken segments from the index. + /// BE CAREFUL. /// - /// <p><b>WARNING</b>: Make sure you only call this when the - /// index is not opened by any writer. + /// <para/><b>WARNING</b>: Make sure you only call this when the + /// index is not opened by any writer. /// </summary> public virtual void FixIndex(Status result) { http://git-wip-us.apache.org/repos/asf/lucenenet/blob/05c8b585/src/Lucene.Net.Core/Index/CompositeReader.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Core/Index/CompositeReader.cs b/src/Lucene.Net.Core/Index/CompositeReader.cs index 71016c5..de5ef2c 100644 --- a/src/Lucene.Net.Core/Index/CompositeReader.cs +++ b/src/Lucene.Net.Core/Index/CompositeReader.cs @@ -27,33 +27,32 @@ namespace Lucene.Net.Index /// <summary> /// Instances of this reader type can only - /// be used to get stored fields from the underlying AtomicReaders, + /// be used to get stored fields from the underlying <see cref="AtomicReader"/>s, /// but it is not possible to directly retrieve postings. To do that, get - /// the <seealso cref="AtomicReaderContext"/> for all sub-readers via <seealso cref="#leaves()"/>. - /// Alternatively, you can mimic an <seealso cref="AtomicReader"/> (with a serious slowdown), - /// by wrapping composite readers with <seealso cref="SlowCompositeReaderWrapper"/>. + /// the <see cref="AtomicReaderContext"/> for all sub-readers via <see cref="AtomicReaderContext.Leaves"/>. + /// Alternatively, you can mimic an <see cref="AtomicReader"/> (with a serious slowdown), + /// by wrapping composite readers with <see cref="SlowCompositeReaderWrapper"/>. /// - /// <p>IndexReader instances for indexes on disk are usually constructed - /// with a call to one of the static <code>DirectoryReader.open()</code> methods, - /// e.g. <seealso cref="DirectoryReader#open(Directory)"/>. <seealso cref="DirectoryReader"/> implements - /// the {@code CompositeReader} interface, it is not possible to directly get postings. - /// <p> Concrete subclasses of IndexReader are usually constructed with a call to - /// one of the static <code>open()</code> methods, e.g. {@link - /// DirectoryReader#open(Directory)}. + /// <para/><see cref="IndexReader"/> instances for indexes on disk are usually constructed + /// with a call to one of the static <c>DirectoryReader.Open()</c> methods, + /// e.g. <see cref="DirectoryReader.Open(Store.Directory)"/>. <see cref="DirectoryReader"/> implements + /// the <see cref="CompositeReader"/> interface, it is not possible to directly get postings. + /// <para/> Concrete subclasses of <see cref="IndexReader"/> are usually constructed with a call to + /// one of the static <c>Open()</c> methods, e.g. <see cref="DirectoryReader.Open(Store.Directory)"/>. /// - /// <p> For efficiency, in this API documents are often referred to via + /// <para/> For efficiency, in this API documents are often referred to via /// <i>document numbers</i>, non-negative integers which each name a unique /// document in the index. These document numbers are ephemeral -- they may change /// as documents are added to and deleted from an index. Clients should thus not /// rely on a given document having the same number between sessions. /// - /// <p> - /// <a name="thread-safety"></a><p><b>NOTE</b>: {@link - /// IndexReader} instances are completely thread + /// <para/> + /// <b>NOTE</b>: + /// <see cref="IndexReader"/> instances are completely thread /// safe, meaning multiple threads can call any of its methods, /// concurrently. If your application requires external /// synchronization, you should <b>not</b> synchronize on the - /// <code>IndexReader</code> instance; use your own + /// <see cref="IndexReader"/> instance; use your own /// (non-Lucene) objects instead. /// </summary> public abstract class CompositeReader : IndexReader @@ -62,7 +61,7 @@ namespace Lucene.Net.Index /// <summary> /// Sole constructor. (For invocation by subclass - /// constructors, typically implicit.) + /// constructors, typically implicit.) /// </summary> protected internal CompositeReader() : base() @@ -98,13 +97,13 @@ namespace Lucene.Net.Index /// <summary> /// Expert: returns the sequential sub readers that this - /// reader is logically composed of. this method may not - /// return {@code null}. + /// reader is logically composed of. This method may not + /// return <c>null</c>. /// - /// <p><b>NOTE:</b> In contrast to previous Lucene versions this method - /// is no longer public, code that wants to get all <seealso cref="AtomicReader"/>s - /// this composite is composed of should use <seealso cref="IndexReader#leaves()"/>. </summary> - /// <seealso cref= IndexReader#leaves() </seealso> + /// <para/><b>NOTE:</b> In contrast to previous Lucene versions this method + /// is no longer public, code that wants to get all <see cref="AtomicReader"/>s + /// this composite is composed of should use <see cref="IndexReader.Leaves"/>. </summary> + /// <seealso cref="IndexReader.Leaves"/> protected internal abstract IList<IndexReader> GetSequentialSubReaders(); public override sealed IndexReaderContext Context http://git-wip-us.apache.org/repos/asf/lucenenet/blob/05c8b585/src/Lucene.Net.Core/Index/CompositeReaderContext.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Core/Index/CompositeReaderContext.cs b/src/Lucene.Net.Core/Index/CompositeReaderContext.cs index 8013a55..846f213 100644 --- a/src/Lucene.Net.Core/Index/CompositeReaderContext.cs +++ b/src/Lucene.Net.Core/Index/CompositeReaderContext.cs @@ -22,7 +22,7 @@ namespace Lucene.Net.Index */ /// <summary> - /// <seealso cref="IndexReaderContext"/> for <seealso cref="CompositeReader"/> instance. + /// <see cref="IndexReaderContext"/> for <see cref="CompositeReader"/> instance. /// </summary> public sealed class CompositeReaderContext : IndexReaderContext { @@ -36,7 +36,7 @@ namespace Lucene.Net.Index } /// <summary> - /// Creates a <seealso cref="CompositeReaderContext"/> for intermediate readers that aren't + /// Creates a <see cref="CompositeReaderContext"/> for intermediate readers that aren't /// not top-level readers in the current context /// </summary> internal CompositeReaderContext(CompositeReaderContext parent, CompositeReader reader, int ordInParent, int docbaseInParent, IList<IndexReaderContext> children) @@ -45,7 +45,7 @@ namespace Lucene.Net.Index } /// <summary> - /// Creates a <seealso cref="CompositeReaderContext"/> for top-level readers with parent set to <code>null</code> + /// Creates a <see cref="CompositeReaderContext"/> for top-level readers with parent set to <c>null</c> /// </summary> internal CompositeReaderContext(CompositeReader reader, IList<IndexReaderContext> children, IList<AtomicReaderContext> leaves) : this(null, reader, 0, 0, children, leaves) http://git-wip-us.apache.org/repos/asf/lucenenet/blob/05c8b585/src/Lucene.Net.Core/Index/ConcurrentMergeScheduler.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Core/Index/ConcurrentMergeScheduler.cs b/src/Lucene.Net.Core/Index/ConcurrentMergeScheduler.cs index 8cd99cd..8d24ac6 100644 --- a/src/Lucene.Net.Core/Index/ConcurrentMergeScheduler.cs +++ b/src/Lucene.Net.Core/Index/ConcurrentMergeScheduler.cs @@ -27,32 +27,32 @@ namespace Lucene.Net.Index using Directory = Lucene.Net.Store.Directory; /// <summary> - /// A <seealso cref="MergeScheduler"/> that runs each merge using a - /// separate thread. + /// A <see cref="MergeScheduler"/> that runs each merge using a + /// separate thread. /// - /// <p>Specify the max number of threads that may run at - /// once, and the maximum number of simultaneous merges - /// with <seealso cref="#setMaxMergesAndThreads"/>.</p> + /// <para>Specify the max number of threads that may run at + /// once, and the maximum number of simultaneous merges + /// with <see cref="SetMaxMergesAndThreads"/>.</para> /// - /// <p>If the number of merges exceeds the max number of threads - /// then the largest merges are paused until one of the smaller - /// merges completes.</p> + /// <para>If the number of merges exceeds the max number of threads + /// then the largest merges are paused until one of the smaller + /// merges completes.</para> /// - /// <p>If more than <seealso cref="#getMaxMergeCount"/> merges are - /// requested then this class will forcefully throttle the - /// incoming threads by pausing until one more more merges - /// complete.</p> + /// <para>If more than <see cref="MaxMergeCount"/> merges are + /// requested then this class will forcefully throttle the + /// incoming threads by pausing until one more more merges + /// complete.</para> /// </summary> public class ConcurrentMergeScheduler : MergeScheduler, IConcurrentMergeScheduler { private int mergeThreadPriority = -1; /// <summary> - /// List of currently active <seealso cref="MergeThread"/>s. </summary> + /// List of currently active <see cref="MergeThread"/>s. </summary> protected internal IList<MergeThread> m_mergeThreads = new List<MergeThread>(); /// <summary> - /// Default {@code maxThreadCount}. + /// Default <see cref="MaxThreadCount"/>. /// We default to 1: tests on spinning-magnet drives showed slower /// indexing performance if more than one merge thread runs at /// once (though on an SSD it was faster) @@ -60,7 +60,7 @@ namespace Lucene.Net.Index public const int DEFAULT_MAX_THREAD_COUNT = 1; /// <summary> - /// Default {@code maxMergeCount}. </summary> + /// Default <see cref="MaxMergeCount"/>. </summary> public const int DEFAULT_MAX_MERGE_COUNT = 2; // Max number of merge threads allowed to be running at @@ -76,22 +76,22 @@ namespace Lucene.Net.Index private int maxMergeCount = DEFAULT_MAX_MERGE_COUNT; /// <summary> - /// <seealso cref="Directory"/> that holds the index. </summary> + /// <see cref="Directory"/> that holds the index. </summary> protected internal Directory m_dir; /// <summary> - /// <seealso cref="IndexWriter"/> that owns this instance. </summary> + /// <see cref="IndexWriter"/> that owns this instance. </summary> protected internal IndexWriter m_writer; /// <summary> - /// How many <seealso cref="MergeThread"/>s have kicked off (this is use - /// to name them). + /// How many <see cref="MergeThread"/>s have kicked off (this is use + /// to name them). /// </summary> protected internal int m_mergeThreadCount; /// <summary> /// Sole constructor, with all settings set to default - /// values. + /// values. /// </summary> public ConcurrentMergeScheduler() { @@ -105,9 +105,9 @@ namespace Lucene.Net.Index /// threads running, the incoming thread (that is calling /// add/updateDocument) will block until a merge thread /// has completed. Note that we will only run the - /// smallest <code>maxThreadCount</code> merges at a time. </param> - /// <param name="maxThreadCount"> the max # simultaneous merge threads that should - /// be running at once. this must be <= <code>maxMergeCount</code> </param> + /// smallest <paramref name="maxThreadCount"/> merges at a time. </param> + /// <param name="maxThreadCount"> The max # simultaneous merge threads that should + /// be running at once. This must be <= <paramref name="maxMergeCount"/> </param> public virtual void SetMaxMergesAndThreads(int maxMergeCount, int maxThreadCount) { if (maxThreadCount < 1) @@ -127,9 +127,9 @@ namespace Lucene.Net.Index } /// <summary> - /// Returns {@code maxThreadCount}. + /// Returns <see cref="maxThreadCount"/>. /// </summary> - /// <seealso cref= #setMaxMergesAndThreads(int, int) </seealso> + /// <seealso cref="SetMaxMergesAndThreads(int, int)"/> public virtual int MaxThreadCount { get @@ -139,7 +139,7 @@ namespace Lucene.Net.Index } /// <summary> - /// See <seealso cref="#setMaxMergesAndThreads"/>. </summary> + /// See <see cref="SetMaxMergesAndThreads(int, int)"/>. </summary> public virtual int MaxMergeCount { get @@ -150,9 +150,9 @@ namespace Lucene.Net.Index /// <summary> /// Return the priority that merge threads run at. By - /// default the priority is 1 plus the priority of (ie, - /// slightly higher priority than) the first thread that - /// calls merge. + /// default the priority is 1 plus the priority of (ie, + /// slightly higher priority than) the first thread that + /// calls merge. /// </summary> public virtual int MergeThreadPriority { @@ -188,7 +188,7 @@ namespace Lucene.Net.Index } /// <summary> - /// Sorts <seealso cref="MergeThread"/>s; larger merges come first. </summary> + /// Sorts <see cref="MergeThread"/>s; larger merges come first. </summary> protected internal static readonly IComparer<MergeThread> compareByMergeDocCount = new ComparerAnonymousInnerClassHelper(); private class ComparerAnonymousInnerClassHelper : IComparer<MergeThread> @@ -210,8 +210,8 @@ namespace Lucene.Net.Index } /// <summary> - /// Called whenever the running merges have changed, to pause & unpause - /// threads. this method sorts the merge threads by their merge size in + /// Called whenever the running merges have changed, to pause & unpause + /// threads. This method sorts the merge threads by their merge size in /// descending order and then pauses/unpauses threads from first to last -- /// that way, smaller merges are guaranteed to run before larger ones. /// </summary> @@ -290,14 +290,15 @@ namespace Lucene.Net.Index } /// <summary> - /// Returns true if verbosing is enabled. this method is usually used in - /// conjunction with <seealso cref="#message(String)"/>, like that: + /// Returns <c>true</c> if verbosing is enabled. This method is usually used in + /// conjunction with <see cref="Message(String)"/>, like that: /// - /// <pre class="prettyprint"> - /// if (verbose()) { - /// message("your message"); + /// <code> + /// if (IsVerbose) + /// { + /// Message("your message"); /// } - /// </pre> + /// </code> /// </summary> protected virtual bool IsVerbose { @@ -305,8 +306,8 @@ namespace Lucene.Net.Index } /// <summary> - /// Outputs the given message - this method assumes <seealso cref="#verbose()"/> was - /// called and returned true. + /// Outputs the given message - this method assumes <see cref="IsVerbose"/> was + /// called and returned <c>true</c>. /// </summary> protected internal virtual void Message(string message) { @@ -336,7 +337,7 @@ namespace Lucene.Net.Index } /// <summary> - /// Wait for any running merge threads to finish. this call is not interruptible as used by <seealso cref="#close()"/>. </summary> + /// Wait for any running merge threads to finish. This call is not interruptible as used by <see cref="Dispose(bool)"/>. </summary> public virtual void Sync() { bool interrupted = false; @@ -388,7 +389,7 @@ namespace Lucene.Net.Index /// <summary> /// Returns the number of merge threads that are alive. Note that this number - /// is <= <seealso cref="#mergeThreads"/> size. + /// is <= <see cref="m_mergeThreads"/> size. /// </summary> protected virtual int MergeThreadCount { @@ -521,14 +522,14 @@ namespace Lucene.Net.Index } /// <summary> - /// Does the actual merge, by calling <seealso cref="IndexWriter#merge"/> </summary> + /// Does the actual merge, by calling <see cref="IndexWriter.Merge(MergePolicy.OneMerge)"/> </summary> protected virtual void DoMerge(MergePolicy.OneMerge merge) { m_writer.Merge(merge); } /// <summary> - /// Create and return a new MergeThread </summary> + /// Create and return a new <see cref="MergeThread"/> </summary> protected virtual MergeThread GetMergeThread(IndexWriter writer, MergePolicy.OneMerge merge) { lock (this) @@ -543,7 +544,7 @@ namespace Lucene.Net.Index /// <summary> /// Runs a merge thread, which may run one or more merges - /// in sequence. + /// in sequence. /// </summary> protected internal class MergeThread : ThreadClass//System.Threading.Thread { @@ -584,8 +585,8 @@ namespace Lucene.Net.Index } /// <summary> - /// Return the current merge, or null if this {@code - /// MergeThread} is done. + /// Return the current merge, or <c>null</c> if this + /// <see cref="MergeThread"/> is done. /// </summary> public virtual MergePolicy.OneMerge CurrentMerge { @@ -709,7 +710,7 @@ namespace Lucene.Net.Index /// <summary> /// Called when an exception is hit in a background merge - /// thread + /// thread /// </summary> protected virtual void HandleMergeException(Exception exc) { http://git-wip-us.apache.org/repos/asf/lucenenet/blob/05c8b585/src/Lucene.Net.Core/Index/CorruptIndexException.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Core/Index/CorruptIndexException.cs b/src/Lucene.Net.Core/Index/CorruptIndexException.cs index c8fcc5f..7a0c565 100644 --- a/src/Lucene.Net.Core/Index/CorruptIndexException.cs +++ b/src/Lucene.Net.Core/Index/CorruptIndexException.cs @@ -21,7 +21,7 @@ namespace Lucene.Net.Index */ /// <summary> - /// this exception is thrown when Lucene detects + /// This exception is thrown when Lucene detects /// an inconsistency in the index. /// </summary> // LUCENENET: All exeption classes should be marked serializable @@ -31,12 +31,14 @@ namespace Lucene.Net.Index public class CorruptIndexException : IOException // LUCENENENET specific - made public instead of internal because there are public subclasses { /// <summary> - /// Sole constructor. </summary> + /// Constructor. </summary> public CorruptIndexException(string message) : base(message) { } + /// <summary> + /// Constructor. </summary> public CorruptIndexException(string message, Exception ex) : base(message, ex) {
