Lucene.Net.Codecs.Compressing: Fixed XML documentation comment warnings
Project: http://git-wip-us.apache.org/repos/asf/lucenenet/repo Commit: http://git-wip-us.apache.org/repos/asf/lucenenet/commit/5dc5193a Tree: http://git-wip-us.apache.org/repos/asf/lucenenet/tree/5dc5193a Diff: http://git-wip-us.apache.org/repos/asf/lucenenet/diff/5dc5193a Branch: refs/heads/master Commit: 5dc5193a89e01c703095c653325f4b665aa386b9 Parents: 95b5d4b Author: Shad Storhaug <[email protected]> Authored: Mon Jun 5 15:08:06 2017 +0700 Committer: Shad Storhaug <[email protected]> Committed: Tue Jun 6 06:58:42 2017 +0700 ---------------------------------------------------------------------- CONTRIBUTING.md | 5 +- .../CompressingStoredFieldsFormat.cs | 61 ++++++++++---------- .../CompressingStoredFieldsIndexReader.cs | 3 +- .../CompressingStoredFieldsIndexWriter.cs | 49 ++++++++-------- .../CompressingStoredFieldsReader.cs | 9 +-- .../CompressingStoredFieldsWriter.cs | 5 +- .../Compressing/CompressingTermVectorsFormat.cs | 35 +++++------ .../Compressing/CompressingTermVectorsReader.cs | 5 +- .../Compressing/CompressingTermVectorsWriter.cs | 9 +-- .../Codecs/Compressing/CompressionMode.cs | 9 +-- src/Lucene.Net/Codecs/Compressing/Compressor.cs | 4 +- .../Codecs/Compressing/Decompressor.cs | 22 +++---- src/Lucene.Net/Codecs/Compressing/LZ4.cs | 20 +++---- 13 files changed, 123 insertions(+), 113 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/lucenenet/blob/5dc5193a/CONTRIBUTING.md ---------------------------------------------------------------------- diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 5c39dc4..36b780b 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -50,9 +50,8 @@ helpers to help with that, see for examples see our [Java style methods to avoid ### Documentation Comments == up for grabs: -1. Lucene.Net.Core (project) - 1. Codecs.Compressing (namespace) - 2. Util.Packed (namespace) +1. Lucene.Net (project) + 1. Util.Packed (namespace) 2. Lucene.Net.Codecs (project) 1. Appending (namespace) 2. BlockTerms (namespace) http://git-wip-us.apache.org/repos/asf/lucenenet/blob/5dc5193a/src/Lucene.Net/Codecs/Compressing/CompressingStoredFieldsFormat.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Codecs/Compressing/CompressingStoredFieldsFormat.cs b/src/Lucene.Net/Codecs/Compressing/CompressingStoredFieldsFormat.cs index 2577368..c88d8e7 100644 --- a/src/Lucene.Net/Codecs/Compressing/CompressingStoredFieldsFormat.cs +++ b/src/Lucene.Net/Codecs/Compressing/CompressingStoredFieldsFormat.cs @@ -23,17 +23,18 @@ namespace Lucene.Net.Codecs.Compressing using SegmentInfo = Lucene.Net.Index.SegmentInfo; /// <summary> - /// A <seealso cref="StoredFieldsFormat"/> that is very similar to - /// <seealso cref="Lucene40StoredFieldsFormat"/> but compresses documents in chunks in + /// A <see cref="StoredFieldsFormat"/> that is very similar to + /// <see cref="Lucene40.Lucene40StoredFieldsFormat"/> but compresses documents in chunks in /// order to improve the compression ratio. - /// <p> - /// For a chunk size of <tt>chunkSize</tt> bytes, this <seealso cref="StoredFieldsFormat"/> - /// does not support documents larger than (<tt>2<sup>31</sup> - chunkSize</tt>) + /// <para/> + /// For a chunk size of <c>chunkSize</c> bytes, this <see cref="StoredFieldsFormat"/> + /// does not support documents larger than (<c>2<sup>31</sup> - chunkSize</c>) /// bytes. In case this is a problem, you should use another format, such as - /// <seealso cref="Lucene40StoredFieldsFormat"/>. - /// <p> - /// For optimal performance, you should use a <seealso cref="MergePolicy"/> that returns + /// <see cref="Lucene40.Lucene40StoredFieldsFormat"/>. + /// <para/> + /// For optimal performance, you should use a <see cref="Index.MergePolicy"/> that returns /// segments that have the biggest byte size first. + /// <para/> /// @lucene.experimental /// </summary> public class CompressingStoredFieldsFormat : StoredFieldsFormat @@ -44,47 +45,47 @@ namespace Lucene.Net.Codecs.Compressing private readonly int chunkSize; /// <summary> - /// Create a new <seealso cref="CompressingStoredFieldsFormat"/> with an empty segment + /// Create a new <see cref="CompressingStoredFieldsFormat"/> with an empty segment /// suffix. /// </summary> - /// <seealso cref= CompressingStoredFieldsFormat#CompressingStoredFieldsFormat(String, String, CompressionMode, int) </seealso> + /// <seealso cref="CompressingStoredFieldsFormat.CompressingStoredFieldsFormat(string, string, CompressionMode, int)"/> public CompressingStoredFieldsFormat(string formatName, CompressionMode compressionMode, int chunkSize) : this(formatName, "", compressionMode, chunkSize) { } /// <summary> - /// Create a new <seealso cref="CompressingStoredFieldsFormat"/>. - /// <p> - /// <code>formatName</code> is the name of the format. this name will be used + /// Create a new <see cref="CompressingStoredFieldsFormat"/>. + /// <para/> + /// <paramref name="formatName"/> is the name of the format. This name will be used /// in the file formats to perform - /// <seealso cref="CodecUtil#checkHeader(Lucene.Net.Store.DataInput, String, int, int) codec header checks"/>. - /// <p> - /// <code>segmentSuffix</code> is the segment suffix. this suffix is added to + /// codec header checks (<see cref="CodecUtil.CheckHeader(Lucene.Net.Store.DataInput, string, int, int)"/>). + /// <para/> + /// <paramref name="segmentSuffix"/> is the segment suffix. this suffix is added to /// the result file name only if it's not the empty string. - /// <p> - /// The <code>compressionMode</code> parameter allows you to choose between + /// <para/> + /// The <paramref name="compressionMode"/> parameter allows you to choose between /// compression algorithms that have various compression and decompression /// speeds so that you can pick the one that best fits your indexing and /// searching throughput. You should never instantiate two - /// <seealso cref="CompressingStoredFieldsFormat"/>s that have the same name but - /// different <seealso cref="compressionMode"/>s. - /// <p> - /// <code>chunkSize</code> is the minimum byte size of a chunk of documents. - /// A value of <code>1</code> can make sense if there is redundancy across + /// <see cref="CompressingStoredFieldsFormat"/>s that have the same name but + /// different <see cref="compressionMode"/>s. + /// <para/> + /// <paramref name="chunkSize"/> is the minimum byte size of a chunk of documents. + /// A value of <c>1</c> can make sense if there is redundancy across /// fields. In that case, both performance and compression ratio should be - /// better than with <seealso cref="Lucene40StoredFieldsFormat"/> with compressed + /// better than with <see cref="Lucene40.Lucene40StoredFieldsFormat"/> with compressed /// fields. - /// <p> - /// Higher values of <code>chunkSize</code> should improve the compression + /// <para/> + /// Higher values of <paramref name="chunkSize"/> should improve the compression /// ratio but will require more memory at indexing time and might make document /// loading a little slower (depending on the size of your OS cache compared /// to the size of your index). /// </summary> - /// <param name="formatName"> the name of the <seealso cref="StoredFieldsFormat"/> </param> - /// <param name="compressionMode"> the <seealso cref="compressionMode"/> to use </param> - /// <param name="chunkSize"> the minimum number of bytes of a single chunk of stored documents </param> - /// <seealso cref= compressionMode </seealso> + /// <param name="formatName"> The name of the <see cref="StoredFieldsFormat"/>. </param> + /// <param name="compressionMode"> The <see cref="CompressionMode"/> to use. </param> + /// <param name="chunkSize"> The minimum number of bytes of a single chunk of stored documents. </param> + /// <seealso cref="CompressionMode"/> public CompressingStoredFieldsFormat(string formatName, string segmentSuffix, CompressionMode compressionMode, int chunkSize) { this.formatName = formatName; http://git-wip-us.apache.org/repos/asf/lucenenet/blob/5dc5193a/src/Lucene.Net/Codecs/Compressing/CompressingStoredFieldsIndexReader.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Codecs/Compressing/CompressingStoredFieldsIndexReader.cs b/src/Lucene.Net/Codecs/Compressing/CompressingStoredFieldsIndexReader.cs index a27fc40..fb889e6 100644 --- a/src/Lucene.Net/Codecs/Compressing/CompressingStoredFieldsIndexReader.cs +++ b/src/Lucene.Net/Codecs/Compressing/CompressingStoredFieldsIndexReader.cs @@ -27,7 +27,8 @@ namespace Lucene.Net.Codecs.Compressing using SegmentInfo = Lucene.Net.Index.SegmentInfo; /// <summary> - /// Random-access reader for <seealso cref="CompressingStoredFieldsIndexWriter"/>. + /// Random-access reader for <see cref="CompressingStoredFieldsIndexWriter"/>. + /// <para/> /// @lucene.internal /// </summary> public sealed class CompressingStoredFieldsIndexReader http://git-wip-us.apache.org/repos/asf/lucenenet/blob/5dc5193a/src/Lucene.Net/Codecs/Compressing/CompressingStoredFieldsIndexWriter.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Codecs/Compressing/CompressingStoredFieldsIndexWriter.cs b/src/Lucene.Net/Codecs/Compressing/CompressingStoredFieldsIndexWriter.cs index 981e476..588cc2b 100644 --- a/src/Lucene.Net/Codecs/Compressing/CompressingStoredFieldsIndexWriter.cs +++ b/src/Lucene.Net/Codecs/Compressing/CompressingStoredFieldsIndexWriter.cs @@ -24,45 +24,48 @@ namespace Lucene.Net.Codecs.Compressing using PackedInt32s = Lucene.Net.Util.Packed.PackedInt32s; /// <summary> - /// Efficient index format for block-based <seealso cref="Codec"/>s. - /// <p> this writer generates a file which can be loaded into memory using + /// Efficient index format for block-based <see cref="Codec"/>s. + /// <para/> this writer generates a file which can be loaded into memory using /// memory-efficient data structures to quickly locate the block that contains /// any document. - /// <p>In order to have a compact in-memory representation, for every block of + /// <para>In order to have a compact in-memory representation, for every block of /// 1024 chunks, this index computes the average number of bytes per - /// chunk and for every chunk, only stores the difference between<ul> + /// chunk and for every chunk, only stores the difference between + /// <list type="bullet"> /// <li>${chunk number} * ${average length of a chunk}</li> - /// <li>and the actual start offset of the chunk</li></ul></p> - /// <p>Data is written as follows:</p> - /// <ul> + /// <li>and the actual start offset of the chunk</li> + /// </list> + /// </para> + /// <para>Data is written as follows:</para> + /// <list type="bullet"> /// <li>PackedIntsVersion, <Block><sup>BlockCount</sup>, BlocksEndMarker</li> - /// <li>PackedIntsVersion --> <seealso cref="PackedInt32s#VERSION_CURRENT"/> as a <seealso cref="DataOutput#writeVInt VInt"/></li> - /// <li>BlocksEndMarker --> <tt>0</tt> as a <seealso cref="DataOutput#writeVInt VInt"/>, this marks the end of blocks since blocks are not allowed to start with <tt>0</tt></li> + /// <li>PackedIntsVersion --> <see cref="PackedInt32s.VERSION_CURRENT"/> as a VInt (<see cref="Store.DataOutput.WriteVInt32(int)"/>) </li> + /// <li>BlocksEndMarker --> <tt>0</tt> as a VInt (<see cref="Store.DataOutput.WriteVInt32(int)"/>) , this marks the end of blocks since blocks are not allowed to start with <tt>0</tt></li> /// <li>Block --> BlockChunks, <DocBases>, <StartPointers></li> - /// <li>BlockChunks --> a <seealso cref="DataOutput#writeVInt VInt"/> which is the number of chunks encoded in the block</li> + /// <li>BlockChunks --> a VInt (<see cref="Store.DataOutput.WriteVInt32(int)"/>) which is the number of chunks encoded in the block</li> /// <li>DocBases --> DocBase, AvgChunkDocs, BitsPerDocBaseDelta, DocBaseDeltas</li> - /// <li>DocBase --> first document ID of the block of chunks, as a <seealso cref="DataOutput#writeVInt VInt"/></li> - /// <li>AvgChunkDocs --> average number of documents in a single chunk, as a <seealso cref="DataOutput#writeVInt VInt"/></li> + /// <li>DocBase --> first document ID of the block of chunks, as a VInt (<see cref="Store.DataOutput.WriteVInt32(int)"/>) </li> + /// <li>AvgChunkDocs --> average number of documents in a single chunk, as a VInt (<see cref="Store.DataOutput.WriteVInt32(int)"/>) </li> /// <li>BitsPerDocBaseDelta --> number of bits required to represent a delta from the average using <a href="https://developers.google.com/protocol-buffers/docs/encoding#types";>ZigZag encoding</a></li> - /// <li>DocBaseDeltas --> <seealso cref="PackedInt32s packed"/> array of BlockChunks elements of BitsPerDocBaseDelta bits each, representing the deltas from the average doc base using <a href="https://developers.google.com/protocol-buffers/docs/encoding#types";>ZigZag encoding</a>.</li> + /// <li>DocBaseDeltas --> packed (<see cref="PackedInt32s"/>) array of BlockChunks elements of BitsPerDocBaseDelta bits each, representing the deltas from the average doc base using <a href="https://developers.google.com/protocol-buffers/docs/encoding#types";>ZigZag encoding</a>.</li> /// <li>StartPointers --> StartPointerBase, AvgChunkSize, BitsPerStartPointerDelta, StartPointerDeltas</li> - /// <li>StartPointerBase --> the first start pointer of the block, as a <seealso cref="DataOutput#writeVLong VLong"/></li> - /// <li>AvgChunkSize --> the average size of a chunk of compressed documents, as a <seealso cref="DataOutput#writeVLong VLong"/></li> + /// <li>StartPointerBase --> the first start pointer of the block, as a VLong (<see cref="Store.DataOutput.WriteVInt64(long)"/>) </li> + /// <li>AvgChunkSize --> the average size of a chunk of compressed documents, as a VLong (<see cref="Store.DataOutput.WriteVInt64(long)"/>) </li> /// <li>BitsPerStartPointerDelta --> number of bits required to represent a delta from the average using <a href="https://developers.google.com/protocol-buffers/docs/encoding#types";>ZigZag encoding</a></li> - /// <li>StartPointerDeltas --> <seealso cref="PackedInt32s packed"/> array of BlockChunks elements of BitsPerStartPointerDelta bits each, representing the deltas from the average start pointer using <a href="https://developers.google.com/protocol-buffers/docs/encoding#types";>ZigZag encoding</a></li> - /// <li>Footer --> <seealso cref="CodecUtil#writeFooter CodecFooter"/></li> - /// </ul> - /// <p>Notes</p> - /// <ul> + /// <li>StartPointerDeltas --> packed (<see cref="PackedInt32s"/>) array of BlockChunks elements of BitsPerStartPointerDelta bits each, representing the deltas from the average start pointer using <a href="https://developers.google.com/protocol-buffers/docs/encoding#types";>ZigZag encoding</a></li> + /// <li>Footer --> CodecFooter (<see cref="CodecUtil.WriteFooter(IndexOutput)"/>) </li> + /// </list> + /// <para>Notes</para> + /// <list type="bullet"> /// <li>For any block, the doc base of the n-th chunk can be restored with - /// <code>DocBase + AvgChunkDocs * n + DocBaseDeltas[n]</code>.</li> + /// <c>DocBase + AvgChunkDocs * n + DocBaseDeltas[n]</c>.</li> /// <li>For any block, the start pointer of the n-th chunk can be restored with - /// <code>StartPointerBase + AvgChunkSize * n + StartPointerDeltas[n]</code>.</li> + /// <c>StartPointerBase + AvgChunkSize * n + StartPointerDeltas[n]</c>.</li> /// <li>Once data is loaded into memory, you can lookup the start pointer of any /// document by performing two binary searches: a first one based on the values /// of DocBase in order to find the right block, and then inside the block based /// on DocBaseDeltas (by reconstructing the doc bases for every chunk).</li> - /// </ul> + /// </list> /// @lucene.internal /// </summary> public sealed class CompressingStoredFieldsIndexWriter : IDisposable http://git-wip-us.apache.org/repos/asf/lucenenet/blob/5dc5193a/src/Lucene.Net/Codecs/Compressing/CompressingStoredFieldsReader.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Codecs/Compressing/CompressingStoredFieldsReader.cs b/src/Lucene.Net/Codecs/Compressing/CompressingStoredFieldsReader.cs index 335aa08..b2fbb74 100644 --- a/src/Lucene.Net/Codecs/Compressing/CompressingStoredFieldsReader.cs +++ b/src/Lucene.Net/Codecs/Compressing/CompressingStoredFieldsReader.cs @@ -43,7 +43,8 @@ namespace Lucene.Net.Codecs.Compressing using StoredFieldVisitor = Lucene.Net.Index.StoredFieldVisitor; /// <summary> - /// <seealso cref="StoredFieldsReader"/> impl for <seealso cref="CompressingStoredFieldsFormat"/>. + /// <see cref="StoredFieldsReader"/> impl for <see cref="CompressingStoredFieldsFormat"/>. + /// <para/> /// @lucene.experimental /// </summary> public sealed class CompressingStoredFieldsReader : StoredFieldsReader @@ -163,7 +164,7 @@ namespace Lucene.Net.Codecs.Compressing } } - /// <exception cref="ObjectDisposedException"> if this FieldsReader is closed </exception> + /// <exception cref="ObjectDisposedException"> If this FieldsReader is disposed. </exception> private void EnsureOpen() { if (closed) @@ -173,7 +174,7 @@ namespace Lucene.Net.Codecs.Compressing } /// <summary> - /// Close the underlying <seealso cref="IndexInput"/>s. + /// Dispose the underlying <see cref="IndexInput"/>s. /// </summary> protected override void Dispose(bool disposing) { @@ -501,7 +502,7 @@ namespace Lucene.Net.Codecs.Compressing } /// <summary> - /// Go to the chunk containing the provided doc ID. + /// Go to the chunk containing the provided <paramref name="doc"/> ID. /// </summary> internal void Next(int doc) { http://git-wip-us.apache.org/repos/asf/lucenenet/blob/5dc5193a/src/Lucene.Net/Codecs/Compressing/CompressingStoredFieldsWriter.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Codecs/Compressing/CompressingStoredFieldsWriter.cs b/src/Lucene.Net/Codecs/Compressing/CompressingStoredFieldsWriter.cs index 4f8f949..465e1d1 100644 --- a/src/Lucene.Net/Codecs/Compressing/CompressingStoredFieldsWriter.cs +++ b/src/Lucene.Net/Codecs/Compressing/CompressingStoredFieldsWriter.cs @@ -28,7 +28,8 @@ namespace Lucene.Net.Codecs.Compressing */ /// <summary> - /// <seealso cref="StoredFieldsWriter"/> impl for <seealso cref="CompressingStoredFieldsFormat"/>. + /// <see cref="StoredFieldsWriter"/> impl for <see cref="CompressingStoredFieldsFormat"/>. + /// <para/> /// @lucene.experimental /// </summary> public sealed class CompressingStoredFieldsWriter : StoredFieldsWriter @@ -167,7 +168,7 @@ namespace Lucene.Net.Codecs.Compressing } /// <summary> - /// NOTE: This was saveInts() in Lucene + /// NOTE: This was saveInts() in Lucene. /// </summary> private static void SaveInt32s(int[] values, int length, DataOutput @out) { http://git-wip-us.apache.org/repos/asf/lucenenet/blob/5dc5193a/src/Lucene.Net/Codecs/Compressing/CompressingTermVectorsFormat.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Codecs/Compressing/CompressingTermVectorsFormat.cs b/src/Lucene.Net/Codecs/Compressing/CompressingTermVectorsFormat.cs index 8952cc5..7d4a22e 100644 --- a/src/Lucene.Net/Codecs/Compressing/CompressingTermVectorsFormat.cs +++ b/src/Lucene.Net/Codecs/Compressing/CompressingTermVectorsFormat.cs @@ -24,8 +24,9 @@ namespace Lucene.Net.Codecs.Compressing using SegmentInfo = Lucene.Net.Index.SegmentInfo; /// <summary> - /// A <seealso cref="TermVectorsFormat"/> that compresses chunks of documents together in + /// A <see cref="TermVectorsFormat"/> that compresses chunks of documents together in /// order to improve the compression ratio. + /// <para/> /// @lucene.experimental /// </summary> public class CompressingTermVectorsFormat : TermVectorsFormat @@ -36,30 +37,30 @@ namespace Lucene.Net.Codecs.Compressing private readonly int chunkSize; /// <summary> - /// Create a new <seealso cref="CompressingTermVectorsFormat"/>. - /// <p> - /// <code>formatName</code> is the name of the format. this name will be used + /// Create a new <see cref="CompressingTermVectorsFormat"/>. + /// <para/> + /// <paramref name="formatName"/> is the name of the format. this name will be used /// in the file formats to perform - /// <seealso cref="CodecUtil#checkHeader(Lucene.Net.Store.DataInput, String, int, int) codec header checks"/>. - /// <p> - /// The <code>compressionMode</code> parameter allows you to choose between + /// codec header checks (<see cref="CodecUtil.CheckHeader(Lucene.Net.Store.DataInput, string, int, int)"/>). + /// <para/> + /// The <paramref name="compressionMode"/> parameter allows you to choose between /// compression algorithms that have various compression and decompression /// speeds so that you can pick the one that best fits your indexing and /// searching throughput. You should never instantiate two - /// <seealso cref="CompressingTermVectorsFormat"/>s that have the same name but - /// different <seealso cref="compressionMode"/>s. - /// <p> - /// <code>chunkSize</code> is the minimum byte size of a chunk of documents. - /// Higher values of <code>chunkSize</code> should improve the compression + /// <see cref="CompressingTermVectorsFormat"/>s that have the same name but + /// different <see cref="CompressionMode"/>s. + /// <para/> + /// <paramref name="chunkSize"/> is the minimum byte size of a chunk of documents. + /// Higher values of <paramref name="chunkSize"/> should improve the compression /// ratio but will require more memory at indexing time and might make document /// loading a little slower (depending on the size of your OS cache compared /// to the size of your index). /// </summary> - /// <param name="formatName"> the name of the <seealso cref="StoredFieldsFormat"/> </param> - /// <param name="segmentSuffix"> a suffix to append to files created by this format </param> - /// <param name="compressionMode"> the <seealso cref="compressionMode"/> to use </param> - /// <param name="chunkSize"> the minimum number of bytes of a single chunk of stored documents </param> - /// <seealso cref= compressionMode </seealso> + /// <param name="formatName"> The name of the <see cref="StoredFieldsFormat"/>. </param> + /// <param name="segmentSuffix"> A suffix to append to files created by this format. </param> + /// <param name="compressionMode"> The <see cref="CompressionMode"/> to use. </param> + /// <param name="chunkSize"> The minimum number of bytes of a single chunk of stored documents. </param> + /// <seealso cref="CompressionMode"/> public CompressingTermVectorsFormat(string formatName, string segmentSuffix, CompressionMode compressionMode, int chunkSize) { this.formatName = formatName; http://git-wip-us.apache.org/repos/asf/lucenenet/blob/5dc5193a/src/Lucene.Net/Codecs/Compressing/CompressingTermVectorsReader.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Codecs/Compressing/CompressingTermVectorsReader.cs b/src/Lucene.Net/Codecs/Compressing/CompressingTermVectorsReader.cs index 2d8ea75..5b69663 100644 --- a/src/Lucene.Net/Codecs/Compressing/CompressingTermVectorsReader.cs +++ b/src/Lucene.Net/Codecs/Compressing/CompressingTermVectorsReader.cs @@ -29,7 +29,8 @@ namespace Lucene.Net.Codecs.Compressing */ /// <summary> - /// <seealso cref="TermVectorsReader"/> for <seealso cref="CompressingTermVectorsFormat"/>. + /// <see cref="TermVectorsReader"/> for <see cref="CompressingTermVectorsFormat"/>. + /// <para/> /// @lucene.experimental /// </summary> public sealed class CompressingTermVectorsReader : TermVectorsReader, IDisposable @@ -174,7 +175,7 @@ namespace Lucene.Net.Codecs.Compressing } } - /// <exception cref="ObjectDisposedException"> if this TermVectorsReader is closed </exception> + /// <exception cref="ObjectDisposedException"> if this <see cref="TermVectorsReader"/> is disposed. </exception> private void EnsureOpen() { if (closed) http://git-wip-us.apache.org/repos/asf/lucenenet/blob/5dc5193a/src/Lucene.Net/Codecs/Compressing/CompressingTermVectorsWriter.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Codecs/Compressing/CompressingTermVectorsWriter.cs b/src/Lucene.Net/Codecs/Compressing/CompressingTermVectorsWriter.cs index 042c319..2d23dbc 100644 --- a/src/Lucene.Net/Codecs/Compressing/CompressingTermVectorsWriter.cs +++ b/src/Lucene.Net/Codecs/Compressing/CompressingTermVectorsWriter.cs @@ -48,7 +48,8 @@ namespace Lucene.Net.Codecs.Compressing using StringHelper = Lucene.Net.Util.StringHelper; /// <summary> - /// <seealso cref="TermVectorsWriter"/> for <seealso cref="CompressingTermVectorsFormat"/>. + /// <see cref="TermVectorsWriter"/> for <see cref="CompressingTermVectorsFormat"/>. + /// <para/> /// @lucene.experimental /// </summary> public sealed class CompressingTermVectorsWriter : TermVectorsWriter @@ -84,7 +85,7 @@ namespace Lucene.Net.Codecs.Compressing private readonly int chunkSize; /// <summary> - /// a pending doc </summary> + /// A pending doc. </summary> private class DocData { private readonly CompressingTermVectorsWriter outerInstance; @@ -152,7 +153,7 @@ namespace Lucene.Net.Codecs.Compressing } /// <summary> - /// a pending field </summary> + /// A pending field. </summary> private class FieldData { private readonly CompressingTermVectorsWriter outerInstance; @@ -441,7 +442,7 @@ namespace Lucene.Net.Codecs.Compressing } /// <summary> - /// Returns a sorted array containing unique field numbers </summary> + /// Returns a sorted array containing unique field numbers. </summary> private int[] FlushFieldNums() { SortedSet<int> fieldNums = new SortedSet<int>(); http://git-wip-us.apache.org/repos/asf/lucenenet/blob/5dc5193a/src/Lucene.Net/Codecs/Compressing/CompressionMode.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Codecs/Compressing/CompressionMode.cs b/src/Lucene.Net/Codecs/Compressing/CompressionMode.cs index ce0857c..dda993a 100644 --- a/src/Lucene.Net/Codecs/Compressing/CompressionMode.cs +++ b/src/Lucene.Net/Codecs/Compressing/CompressionMode.cs @@ -30,6 +30,7 @@ namespace Lucene.Net.Codecs.Compressing /// <summary> /// A compression mode. Tells how much effort should be spent on compression and /// decompression of stored fields. + /// <para/> /// @lucene.experimental /// </summary> public abstract class CompressionMode @@ -95,8 +96,8 @@ namespace Lucene.Net.Codecs.Compressing } /// <summary> - /// this compression mode is similar to <seealso cref="#FAST"/> but it spends more time - /// compressing in order to improve the compression ratio. this compression + /// This compression mode is similar to <see cref="FAST"/> but it spends more time + /// compressing in order to improve the compression ratio. This compression /// mode is best used with indices that have a low update rate but should be /// able to load documents from disk quickly. /// </summary> @@ -131,12 +132,12 @@ namespace Lucene.Net.Codecs.Compressing } /// <summary> - /// Create a new <seealso cref="Compressor"/> instance. + /// Create a new <see cref="Compressor"/> instance. /// </summary> public abstract Compressor NewCompressor(); /// <summary> - /// Create a new <seealso cref="Decompressor"/> instance. + /// Create a new <see cref="Decompressor"/> instance. /// </summary> public abstract Decompressor NewDecompressor(); http://git-wip-us.apache.org/repos/asf/lucenenet/blob/5dc5193a/src/Lucene.Net/Codecs/Compressing/Compressor.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Codecs/Compressing/Compressor.cs b/src/Lucene.Net/Codecs/Compressing/Compressor.cs index 666e90a..0f0e523 100644 --- a/src/Lucene.Net/Codecs/Compressing/Compressor.cs +++ b/src/Lucene.Net/Codecs/Compressing/Compressor.cs @@ -31,8 +31,8 @@ namespace Lucene.Net.Codecs.Compressing } /// <summary> - /// Compress bytes into <code>out</code>. It it the responsibility of the - /// compressor to add all necessary information so that a <seealso cref="Decompressor"/> + /// Compress bytes into <paramref name="out"/>. It it the responsibility of the + /// compressor to add all necessary information so that a <see cref="Decompressor"/> /// will know when to stop decompressing bytes from the stream. /// </summary> public abstract void Compress(byte[] bytes, int off, int len, DataOutput @out); http://git-wip-us.apache.org/repos/asf/lucenenet/blob/5dc5193a/src/Lucene.Net/Codecs/Compressing/Decompressor.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Codecs/Compressing/Decompressor.cs b/src/Lucene.Net/Codecs/Compressing/Decompressor.cs index d1e0641..726841d 100644 --- a/src/Lucene.Net/Codecs/Compressing/Decompressor.cs +++ b/src/Lucene.Net/Codecs/Compressing/Decompressor.cs @@ -33,18 +33,18 @@ namespace Lucene.Net.Codecs.Compressing } /// <summary> - /// Decompress bytes that were stored between offsets <code>offset</code> and - /// <code>offset+length</code> in the original stream from the compressed - /// stream <code>in</code> to <code>bytes</code>. After returning, the length - /// of <code>bytes</code> (<code>bytes.length</code>) must be equal to - /// <code>length</code>. Implementations of this method are free to resize - /// <code>bytes</code> depending on their needs. + /// Decompress bytes that were stored between offsets <paramref name="offset"/> and + /// <c>offset+length</c> in the original stream from the compressed + /// stream <paramref name="in"/> to <paramref name="bytes"/>. After returning, the length + /// of <paramref name="bytes"/> (<c>bytes.Length</c>) must be equal to + /// <paramref name="length"/>. Implementations of this method are free to resize + /// <paramref name="bytes"/> depending on their needs. /// </summary> - /// <param name="in"> the input that stores the compressed stream </param> - /// <param name="originalLength"> the length of the original data (before compression) </param> - /// <param name="offset"> bytes before this offset do not need to be decompressed </param> - /// <param name="length"> bytes after <code>offset+length</code> do not need to be decompressed </param> - /// <param name="bytes"> a <seealso cref="BytesRef"/> where to store the decompressed data </param> + /// <param name="in"> The input that stores the compressed stream. </param> + /// <param name="originalLength"> The length of the original data (before compression). </param> + /// <param name="offset"> Bytes before this offset do not need to be decompressed. </param> + /// <param name="length"> Bytes after <c>offset+length</c> do not need to be decompressed. </param> + /// <param name="bytes"> a <see cref="BytesRef"/> where to store the decompressed data. </param> public abstract void Decompress(DataInput @in, int originalLength, int offset, int length, BytesRef bytes); public abstract object Clone(); http://git-wip-us.apache.org/repos/asf/lucenenet/blob/5dc5193a/src/Lucene.Net/Codecs/Compressing/LZ4.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net/Codecs/Compressing/LZ4.cs b/src/Lucene.Net/Codecs/Compressing/LZ4.cs index cf05994..0c4e38d 100644 --- a/src/Lucene.Net/Codecs/Compressing/LZ4.cs +++ b/src/Lucene.Net/Codecs/Compressing/LZ4.cs @@ -27,7 +27,7 @@ namespace Lucene.Net.Codecs.Compressing /// <summary> /// LZ4 compression and decompression routines. - /// + /// <para/> /// http://code.google.com/p/lz4/ /// http://fastcompression.blogspot.fr/p/lz4.html /// </summary> @@ -56,7 +56,7 @@ namespace Lucene.Net.Codecs.Compressing } /// <summary> - /// NOTE: This was readInt() in Lucene + /// NOTE: This was readInt() in Lucene. /// </summary> private static int ReadInt32(byte[] buf, int i) { @@ -65,7 +65,7 @@ namespace Lucene.Net.Codecs.Compressing } /// <summary> - /// NOTE: This was readIntEquals() in Lucene + /// NOTE: This was readIntEquals() in Lucene. /// </summary> private static bool ReadInt32Equals(byte[] buf, int i, int j) { @@ -94,8 +94,8 @@ namespace Lucene.Net.Codecs.Compressing } /// <summary> - /// Decompress at least <code>decompressedLen</code> bytes into - /// <code>dest[dOff:]</code>. Please note that <code>dest</code> must be large + /// Decompress at least <paramref name="decompressedLen"/> bytes into + /// <c>dest[dOff]</c>. Please note that <paramref name="dest"/> must be large /// enough to be able to hold <b>all</b> decompressed data (meaning that you /// need to know the total decompressed length). /// </summary> @@ -241,8 +241,8 @@ namespace Lucene.Net.Codecs.Compressing } /// <summary> - /// Compress <code>bytes[off:off+len]</code> into <code>out</code> using - /// at most 16KB of memory. <code>ht</code> shouldn't be shared across threads + /// Compress <c>bytes[off:off+len]</c> into <paramref name="out"/> using + /// at most 16KB of memory. <paramref name="ht"/> shouldn't be shared across threads /// but can safely be reused. /// </summary> public static void Compress(byte[] bytes, int off, int len, DataOutput @out, HashTable ht) @@ -475,12 +475,12 @@ namespace Lucene.Net.Codecs.Compressing } /// <summary> - /// Compress <code>bytes[off:off+len]</code> into <code>out</code>. Compared to - /// <seealso cref="LZ4#compress(byte[], int, int, DataOutput, HashTable)"/>, this method + /// Compress <c>bytes[off:off+len]</c> into <paramref name="out"/>. Compared to + /// <see cref="LZ4.Compress(byte[], int, int, DataOutput, HashTable)"/>, this method /// is slower and uses more memory (~ 256KB per thread) but should provide /// better compression ratios (especially on large inputs) because it chooses /// the best match among up to 256 candidates and then performs trade-offs to - /// fix overlapping matches. <code>ht</code> shouldn't be shared across threads + /// fix overlapping matches. <paramref name="ht"/> shouldn't be shared across threads /// but can safely be reused. /// </summary> public static void CompressHC(byte[] src, int srcOff, int srcLen, DataOutput @out, HCHashTable ht)
