lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From nightowl...@apache.org
Subject [37/48] lucenenet git commit: Lucene.Net.Codecs.Lucene45: Fixed XML documentation comment warnings
Date Tue, 06 Jun 2017 00:12:10 GMT
Lucene.Net.Codecs.Lucene45: 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/b27d10c3
Tree: http://git-wip-us.apache.org/repos/asf/lucenenet/tree/b27d10c3
Diff: http://git-wip-us.apache.org/repos/asf/lucenenet/diff/b27d10c3

Branch: refs/heads/master
Commit: b27d10c3b70b0136e45a9387a5cdab5777180211
Parents: 5478f1b
Author: Shad Storhaug <shad@shadstorhaug.com>
Authored: Mon Jun 5 08:33:37 2017 +0700
Committer: Shad Storhaug <shad@shadstorhaug.com>
Committed: Tue Jun 6 06:58:40 2017 +0700

----------------------------------------------------------------------
 CONTRIBUTING.md                                 |   3 +-
 src/Lucene.Net/Codecs/Lucene45/Lucene45Codec.cs |  23 +-
 .../Lucene45/Lucene45DocValuesConsumer.cs       | 162 +-------------
 .../Codecs/Lucene45/Lucene45DocValuesFormat.cs  | 221 ++++++++++---------
 .../Lucene45/Lucene45DocValuesProducer.cs       |  49 ++--
 5 files changed, 156 insertions(+), 302 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b27d10c3/CONTRIBUTING.md
----------------------------------------------------------------------
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 0d350a9..ce132b9 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -56,8 +56,7 @@ helpers to help with that, see for examples see our [Java style methods
to avoid
    3. Codecs.Lucene40 (namespace)
    4. Codecs.Lucene41 (namespace)
    5. Codecs.Lucene42 (namespace)
-   6. Codecs.Lucene45 (namespace)
-   7. Util.Packed (namespace)
+   6. Util.Packed (namespace)
 2. Lucene.Net.Codecs (project)
    1. Appending (namespace)
    2. BlockTerms (namespace)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b27d10c3/src/Lucene.Net/Codecs/Lucene45/Lucene45Codec.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Codecs/Lucene45/Lucene45Codec.cs b/src/Lucene.Net/Codecs/Lucene45/Lucene45Codec.cs
index 8214bd6..b2ccca2 100644
--- a/src/Lucene.Net/Codecs/Lucene45/Lucene45Codec.cs
+++ b/src/Lucene.Net/Codecs/Lucene45/Lucene45Codec.cs
@@ -31,13 +31,14 @@ namespace Lucene.Net.Codecs.Lucene45
     /// <summary>
     /// Implements the Lucene 4.5 index format, with configurable per-field postings
     /// and docvalues formats.
-    /// <p>
+    /// <para/>
     /// If you want to reuse functionality of this codec in another codec, extend
-    /// <seealso cref="FilterCodec"/>.
+    /// <see cref="FilterCodec"/>.
+    /// <para/>
+    /// See <see cref="Lucene.Net.Codecs.Lucene45"/> package documentation for file
format details.
+    /// <para/>
+    /// @lucene.experimental 
     /// </summary>
-    /// <seealso cref= Lucene.Net.Codecs.Lucene45 package documentation for file format
details.
-    /// @lucene.experimental </seealso>
-    /// @deprecated Only for reading old 4.3-4.5 segments
     // NOTE: if we make largish changes in a minor release, easier to just make Lucene46Codec
or whatever
     // if they are backwards compatible or smallish we can probably do the backwards in the
postingsreader
     // (it writes a minor version, etc).
@@ -126,9 +127,9 @@ namespace Lucene.Net.Codecs.Lucene45
 
         /// <summary>
         /// Returns the postings format that should be used for writing
-        ///  new segments of <code>field</code>.
-        ///
-        ///  The default implementation always returns "Lucene41"
+        /// new segments of <paramref name="field"/>.
+        /// <para/>
+        /// The default implementation always returns "Lucene41"
         /// </summary>
         public virtual PostingsFormat GetPostingsFormatForField(string field)
         {
@@ -137,9 +138,9 @@ namespace Lucene.Net.Codecs.Lucene45
 
         /// <summary>
         /// Returns the docvalues format that should be used for writing
-        ///  new segments of <code>field</code>.
-        ///
-        ///  The default implementation always returns "Lucene45"
+        /// new segments of <paramref name="field"/>.
+        /// <para/>
+        /// The default implementation always returns "Lucene45"
         /// </summary>
         public virtual DocValuesFormat GetDocValuesFormatForField(string field)
         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b27d10c3/src/Lucene.Net/Codecs/Lucene45/Lucene45DocValuesConsumer.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Codecs/Lucene45/Lucene45DocValuesConsumer.cs b/src/Lucene.Net/Codecs/Lucene45/Lucene45DocValuesConsumer.cs
index 76ebffa..9907b28 100644
--- a/src/Lucene.Net/Codecs/Lucene45/Lucene45DocValuesConsumer.cs
+++ b/src/Lucene.Net/Codecs/Lucene45/Lucene45DocValuesConsumer.cs
@@ -37,7 +37,7 @@ namespace Lucene.Net.Codecs.Lucene45
     using StringHelper = Lucene.Net.Util.StringHelper;
 
     /// <summary>
-    /// writer for <seealso cref="Lucene45DocValuesFormat"/> </summary>
+    /// Writer for <see cref="Lucene45DocValuesFormat"/> </summary>
     public class Lucene45DocValuesConsumer : DocValuesConsumer, IDisposable
     {
         internal static readonly int BLOCK_SIZE = 16384;
@@ -45,7 +45,7 @@ namespace Lucene.Net.Codecs.Lucene45
         internal static readonly long MISSING_ORD = BitConverter.DoubleToInt64Bits(-1);
 
         /// <summary>
-        /// Compressed using packed blocks of ints. </summary>
+        /// Compressed using packed blocks of <see cref="int"/>s. </summary>
         public const int DELTA_COMPRESSED = 0;
 
         /// <summary>
@@ -70,13 +70,13 @@ namespace Lucene.Net.Codecs.Lucene45
 
         /// <summary>
         /// Standard storage for sorted set values with 1 level of indirection:
-        ///  docId -> address -> ord.
+        /// docId -> address -> ord.
         /// </summary>
         public static readonly int SORTED_SET_WITH_ADDRESSES = 0;
 
         /// <summary>
         /// Single-valued sorted set values, encoded as sorted values, so no level
-        ///  of indirection: docId -> ord.
+        /// of indirection: docId -> ord.
         /// </summary>
         public static readonly int SORTED_SET_SINGLE_VALUED_SORTED = 1;
 
@@ -84,7 +84,7 @@ namespace Lucene.Net.Codecs.Lucene45
         internal readonly int maxDoc;
 
         /// <summary>
-        /// expert: Creates a new writer </summary>
+        /// Expert: Creates a new writer. </summary>
         public Lucene45DocValuesConsumer(SegmentWriteState state, string dataCodec, string
dataExtension, string metaCodec, string metaExtension)
         {
             bool success = false;
@@ -353,7 +353,7 @@ namespace Lucene.Net.Codecs.Lucene45
         }
 
         /// <summary>
-        /// expert: writes a value dictionary for a sorted/sortedset field </summary>
+        /// Expert: writes a value dictionary for a sorted/sortedset field. </summary>
         protected internal virtual void AddTermsDict(FieldInfo field, IEnumerable<BytesRef>
values)
         {
             // first check if its a "fixed-length" terms dict
@@ -498,156 +498,6 @@ namespace Lucene.Net.Codecs.Lucene45
             Debug.Assert(!ordsIter.MoveNext());
         }
 
-        /*
-      private class IterableAnonymousInnerClassHelper : IEnumerable<int>
-	  {
-		  private readonly Lucene45DocValuesConsumer OuterInstance;
-
-		  private IEnumerable<int> DocToOrdCount;
-		  private IEnumerable<long> Ords;
-
-		  public IterableAnonymousInnerClassHelper(IEnumerable<int> docToOrdCount, IEnumerable<long>
ords)
-		  {
-			  //this.OuterInstance = outerInstance;
-			  this.DocToOrdCount = docToOrdCount;
-			  this.Ords = ords;
-		  }
-
-          public virtual IEnumerator<BytesRef> GetEnumerator()
-		  {
-			*/
-        /*IEnumerator<Number> docToOrdCountIt = DocToOrdCount.GetEnumerator();
-      IEnumerator<Number> ordsIt = Ords.GetEnumerator();
-      return new IteratorAnonymousInnerClassHelper(this, docToOrdCountIt, ordsIt);*/
-        /*
-return new SortedSetIterator(DocToOrdCount.GetEnumerator(), Ords.GetEnumerator());
-}
-
-System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
-{
-return GetEnumerator();
-}
-
-private class SortedSetIterator : IEnumerator<BytesRef>
-{
-internal byte[] buffer = new byte[10]; //Initial size, will grow if needed
-internal ByteArrayDataOutput output = new ByteArrayDataOutput();
-internal BytesRef bytesRef = new BytesRef();
-
-internal IEnumerator<int> counts;
-internal IEnumerator<long> ords;
-
-internal SortedSetIterator(IEnumerator<int> counts, IEnumerator<long> ords)
-{
-this.counts = counts;
-this.ords = ords;
-}
-
-public BytesRef Current
-{
-get
-{
-return bytesRef;
-}
-}
-
-public void Dispose()
-{
-counts.Dispose();
-ords.Dispose();
-}
-
-object System.Collections.IEnumerator.Current
-{
-get { return bytesRef;  }
-}
-
-public bool MoveNext()
-{
-if (!counts.MoveNext())
-return false;
-
-int count = counts.Current;
-int maxSize = count * 9;//worst case
-if (maxSize > buffer.Length)
-buffer = ArrayUtil.Grow(buffer, maxSize);
-
-try
-{
-EncodeValues(count);
-}
-catch (System.IO.IOException)
-{
-throw;
-}
-
-bytesRef.Bytes = buffer;
-bytesRef.Offset = 0;
-bytesRef.Length = output.Position;
-
-return true;
-}
-
-private void EncodeValues(int count)
-{
-output.Reset(buffer);
-long lastOrd = 0;
-for (int i = 0; i < count; i++)
-{
-ords.MoveNext();
-long ord = ords.Current;
-output.WriteVLong(ord - lastOrd);
-lastOrd = ord;
-}
-}
-
-public void Reset()
-{
-throw new NotImplementedException();
-}
-}*/
-
-        /*private class IteratorAnonymousInnerClassHelper : IEnumerator<Number>
-        {
-            private readonly IterableAnonymousInnerClassHelper OuterInstance;
-
-            private IEnumerator<Number> DocToOrdCountIt;
-            private IEnumerator<Number> OrdsIt;
-
-            public IteratorAnonymousInnerClassHelper(IterableAnonymousInnerClassHelper outerInstance,
IEnumerator<Number> docToOrdCountIt, IEnumerator<Number> ordsIt)
-            {
-                this.OuterInstance = outerInstance;
-                this.DocToOrdCountIt = docToOrdCountIt;
-                this.OrdsIt = ordsIt;
-            }
-
-            public virtual bool HasNext()
-            {
-              return DocToOrdCountIt.HasNext();
-            }
-
-            public virtual Number Next()
-            {
-              Number ordCount = DocToOrdCountIt.next();
-              if ((long)ordCount == 0)
-              {
-                return MISSING_ORD;
-              }
-              else
-              {
-                Debug.Assert((long)ordCount == 1);
-                return OrdsIt.next();
-              }
-            }
-
-            public virtual void Remove()
-            {
-              throw new System.NotSupportedException();
-            }
-        }*/
-
-        //}
-
         protected override void Dispose(bool disposing)
         {
             if (disposing)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b27d10c3/src/Lucene.Net/Codecs/Lucene45/Lucene45DocValuesFormat.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Codecs/Lucene45/Lucene45DocValuesFormat.cs b/src/Lucene.Net/Codecs/Lucene45/Lucene45DocValuesFormat.cs
index 30cae45..780a2a1 100644
--- a/src/Lucene.Net/Codecs/Lucene45/Lucene45DocValuesFormat.cs
+++ b/src/Lucene.Net/Codecs/Lucene45/Lucene45DocValuesFormat.cs
@@ -22,130 +22,131 @@ namespace Lucene.Net.Codecs.Lucene45
 
     /// <summary>
     /// Lucene 4.5 DocValues format.
-    /// <p>
+    /// <para/>
     /// Encodes the four per-document value types (Numeric,Binary,Sorted,SortedSet) with
these strategies:
-    /// <p>
-    /// <seealso cref="DocValuesType#NUMERIC NUMERIC"/>:
-    /// <ul>
-    ///    <li>Delta-compressed: per-document integers written in blocks of 16k. For
each block
+    /// <para/>
+    /// <see cref="Index.DocValuesType.NUMERIC"/>:
+    /// <list type="bullet">
+    ///    <item><description>Delta-compressed: per-document integers written
in blocks of 16k. For each block
     ///        the minimum value in that block is encoded, and each entry is a delta from
that
     ///        minimum value. Each block of deltas is compressed with bitpacking. For more
-    ///        information, see <seealso cref="BlockPackedWriter"/>.
-    ///    <li>Table-compressed: when the number of unique values is very small (&lt;
256), and
-    ///        when there are unused "gaps" in the range of values used (such as <seealso
cref="SmallFloat"/>),
+    ///        information, see <see cref="Util.Packed.BlockPackedWriter"/>.</description></item>
+    ///    <item><description>Table-compressed: when the number of unique values
is very small (&lt; 256), and
+    ///        when there are unused "gaps" in the range of values used (such as <see
cref="Util.SmallSingle"/>),
     ///        a lookup table is written instead. Each per-document entry is instead the
ordinal
-    ///        to this table, and those ordinals are compressed with bitpacking (<seealso
cref="PackedInts"/>).
-    ///    <li>GCD-compressed: when all numbers share a common divisor, such as dates,
the greatest
-    ///        common denominator (GCD) is computed, and quotients are stored using Delta-compressed
Numerics.
-    /// </ul>
-    /// <p>
-    /// <seealso cref="DocValuesType#BINARY BINARY"/>:
-    /// <ul>
-    ///    <li>Fixed-width Binary: one large concatenated byte[] is written, along
with the fixed length.
-    ///        Each document's value can be addressed directly with multiplication ({@code
docID * length}).
-    ///    <li>Variable-width Binary: one large concatenated byte[] is written, along
with end addresses
+    ///        to this table, and those ordinals are compressed with bitpacking (<see
cref="Util.Packed.PackedInt32s"/>).</description></item>
+    ///    <item><description>GCD-compressed: when all numbers share a common
divisor, such as dates, the greatest
+    ///        common denominator (GCD) is computed, and quotients are stored using Delta-compressed
Numerics.</description></item>
+    /// </list>
+    /// <para/>
+    /// <see cref="Index.DocValuesType.BINARY"/>:
+    /// <list type="bullet">
+    ///    <item><description>Fixed-width Binary: one large concatenated <see
cref="T:byte[]"/> is written, along with the fixed length.
+    ///        Each document's value can be addressed directly with multiplication (<c>docID
* length</c>).</description></item>
+    ///    <item><description>Variable-width Binary: one large concatenated <see
cref="T:byte[]"/> is written, along with end addresses
     ///        for each document. The addresses are written in blocks of 16k, with the current
absolute
     ///        start for the block, and the average (expected) delta per entry. For each
document the
-    ///        deviation from the delta (actual - expected) is written.
-    ///    <li>Prefix-compressed Binary: values are written in chunks of 16, with the
first value written
-    ///        completely and other values sharing prefixes. chunk addresses are written
in blocks of 16k,
+    ///        deviation from the delta (actual - expected) is written.</description></item>
+    ///    <item><description>Prefix-compressed Binary: values are written in
chunks of 16, with the first value written
+    ///        completely and other values sharing prefixes. Chunk addresses are written
in blocks of 16k,
     ///        with the current absolute start for the block, and the average (expected)
delta per entry.
-    ///        For each chunk the deviation from the delta (actual - expected) is written.
-    /// </ul>
-    /// <p>
-    /// <seealso cref="DocValuesType#SORTED SORTED"/>:
-    /// <ul>
-    ///    <li>Sorted: a mapping of ordinals to deduplicated terms is written as Prefix-Compressed
Binary,
-    ///        along with the per-document ordinals written using one of the numeric strategies
above.
-    /// </ul>
-    /// <p>
-    /// <seealso cref="DocValuesType#SORTED_SET SORTED_SET"/>:
-    /// <ul>
-    ///    <li>SortedSet: a mapping of ordinals to deduplicated terms is written as
Prefix-Compressed Binary,
+    ///        For each chunk the deviation from the delta (actual - expected) is written.</description></item>
+    /// </list>
+    /// <para/>
+    /// <see cref="Index.DocValuesType.SORTED"/>:
+    /// <list type="bullet">
+    ///    <item><description>Sorted: a mapping of ordinals to deduplicated terms
is written as Prefix-Compressed Binary,
+    ///        along with the per-document ordinals written using one of the numeric strategies
above.</description></item>
+    /// </list>
+    /// <para/>
+    /// <see cref="Index.DocValuesType.SORTED_SET"/>:
+    /// <list type="bullet">
+    ///    <item><description>SortedSet: a mapping of ordinals to deduplicated
terms is written as Prefix-Compressed Binary,
     ///        an ordinal list and per-document index into this list are written using the
numeric strategies
-    ///        above.
-    /// </ul>
-    /// <p>
+    ///        above.</description></item>
+    /// </list>
+    /// <para/>
     /// Files:
-    /// <ol>
-    ///   <li><tt>.dvd</tt>: DocValues data</li>
-    ///   <li><tt>.dvm</tt>: DocValues metadata</li>
-    /// </ol>
-    /// <ol>
-    ///   <li><a name="dvm" id="dvm"></a>
-    ///   <p>The DocValues metadata or .dvm file.</p>
-    ///   <p>For DocValues field, this stores metadata, such as the offset into the
-    ///      DocValues data (.dvd)</p>
-    ///   <p>DocValues metadata (.dvm) --&gt; Header,&lt;Entry&gt;<sup>NumFields</sup>,Footer</p>
-    ///   <ul>
-    ///     <li>Entry --&gt; NumericEntry | BinaryEntry | SortedEntry | SortedSetEntry</li>
-    ///     <li>NumericEntry --&gt; GCDNumericEntry | TableNumericEntry | DeltaNumericEntry</li>
-    ///     <li>GCDNumericEntry --&gt; NumericHeader,MinValue,GCD</li>
-    ///     <li>TableNumericEntry --&gt; NumericHeader,TableSize,<seealso cref="DataOutput#writeLong
Int64"/><sup>TableSize</sup></li>
-    ///     <li>DeltaNumericEntry --&gt; NumericHeader</li>
-    ///     <li>NumericHeader --&gt; FieldNumber,EntryType,NumericType,MissingOffset,PackedVersion,DataOffset,Count,BlockSize</li>
-    ///     <li>BinaryEntry --&gt; FixedBinaryEntry | VariableBinaryEntry | PrefixBinaryEntry</li>
-    ///     <li>FixedBinaryEntry --&gt; BinaryHeader</li>
-    ///     <li>VariableBinaryEntry --&gt; BinaryHeader,AddressOffset,PackedVersion,BlockSize</li>
-    ///     <li>PrefixBinaryEntry --&gt; BinaryHeader,AddressInterval,AddressOffset,PackedVersion,BlockSize</li>
-    ///     <li>BinaryHeader --&gt; FieldNumber,EntryType,BinaryType,MissingOffset,MinLength,MaxLength,DataOffset</li>
-    ///     <li>SortedEntry --&gt; FieldNumber,EntryType,BinaryEntry,NumericEntry</li>
-    ///     <li>SortedSetEntry --&gt; EntryType,BinaryEntry,NumericEntry,NumericEntry</li>
-    ///     <li>FieldNumber,PackedVersion,MinLength,MaxLength,BlockSize,ValueCount
--&gt; <seealso cref="DataOutput#writeVInt VInt"/></li>
-    ///     <li>EntryType,CompressionType --&gt; <seealso cref="DataOutput#writeByte
Byte"/></li>
-    ///     <li>Header --&gt; <seealso cref="CodecUtil#writeHeader CodecHeader"/></li>
-    ///     <li>MinValue,GCD,MissingOffset,AddressOffset,DataOffset --&gt; <seealso
cref="DataOutput#writeLong Int64"/></li>
-    ///     <li>TableSize --&gt; <seealso cref="DataOutput#writeVInt vInt"/></li>
-    ///     <li>Footer --&gt; <seealso cref="CodecUtil#writeFooter CodecFooter"/></li>
-    ///   </ul>
-    ///   <p>Sorted fields have two entries: a BinaryEntry with the value metadata,
-    ///      and an ordinary NumericEntry for the document-to-ord metadata.</p>
-    ///   <p>SortedSet fields have three entries: a BinaryEntry with the value metadata,
-    ///      and two NumericEntries for the document-to-ord-index and ordinal list metadata.</p>
-    ///   <p>FieldNumber of -1 indicates the end of metadata.</p>
-    ///   <p>EntryType is a 0 (NumericEntry) or 1 (BinaryEntry)</p>
-    ///   <p>DataOffset is the pointer to the start of the data in the DocValues data
(.dvd)</p>
-    ///   <p>NumericType indicates how Numeric values will be compressed:
-    ///      <ul>
-    ///         <li>0 --&gt; delta-compressed. For each block of 16k integers,
every integer is delta-encoded
-    ///             from the minimum value within the block.
-    ///         <li>1 --&gt, gcd-compressed. When all integers share a common divisor,
only quotients are stored
-    ///             using blocks of delta-encoded ints.
-    ///         <li>2 --&gt; table-compressed. When the number of unique numeric
values is small and it would save space,
-    ///             a lookup table of unique values is written, followed by the ordinal for
each document.
-    ///      </ul>
-    ///   <p>BinaryType indicates how Binary values will be stored:
-    ///      <ul>
-    ///         <li>0 --&gt; fixed-width. All values have the same length, addressing
by multiplication.
-    ///         <li>1 --&gt, variable-width. An address for each value is stored.
-    ///         <li>2 --&gt; prefix-compressed. An address to the start of every
interval'th value is stored.
-    ///      </ul>
-    ///   <p>MinLength and MaxLength represent the min and max byte[] value lengths
for Binary values.
+    /// <list type="number">
+    ///   <item><description><c>.dvd</c>: DocValues data</description></item>
+    ///   <item><description><c>.dvm</c>: DocValues metadata</description></item>
+    /// </list>
+    /// <list type="number">
+    ///   <item><description><a name="dvm" id="dvm"></a>
+    ///   <para>The DocValues metadata or .dvm file.</para>
+    ///   <para>For DocValues field, this stores metadata, such as the offset into
the
+    ///      DocValues data (.dvd)</para>
+    ///   <para>DocValues metadata (.dvm) --&gt; Header,&lt;Entry&gt;<sup>NumFields</sup>,Footer</para>
+    ///   <list type="bullet">
+    ///     <item><description>Entry --&gt; NumericEntry | BinaryEntry |
SortedEntry | SortedSetEntry</description></item>
+    ///     <item><description>NumericEntry --&gt; GCDNumericEntry | TableNumericEntry
| DeltaNumericEntry</description></item>
+    ///     <item><description>GCDNumericEntry --&gt; NumericHeader,MinValue,GCD</description></item>
+    ///     <item><description>TableNumericEntry --&gt; NumericHeader,TableSize,Int64
(<see cref="Store.DataOutput.WriteInt64(long)"/>) <sup>TableSize</sup></description></item>
+    ///     <item><description>DeltaNumericEntry --&gt; NumericHeader</description></item>
+    ///     <item><description>NumericHeader --&gt; FieldNumber,EntryType,NumericType,MissingOffset,PackedVersion,DataOffset,Count,BlockSize</description></item>
+    ///     <item><description>BinaryEntry --&gt; FixedBinaryEntry | VariableBinaryEntry
| PrefixBinaryEntry</description></item>
+    ///     <item><description>FixedBinaryEntry --&gt; BinaryHeader</description></item>
+    ///     <item><description>VariableBinaryEntry --&gt; BinaryHeader,AddressOffset,PackedVersion,BlockSize</description></item>
+    ///     <item><description>PrefixBinaryEntry --&gt; BinaryHeader,AddressInterval,AddressOffset,PackedVersion,BlockSize</description></item>
+    ///     <item><description>BinaryHeader --&gt; FieldNumber,EntryType,BinaryType,MissingOffset,MinLength,MaxLength,DataOffset</description></item>
+    ///     <item><description>SortedEntry --&gt; FieldNumber,EntryType,BinaryEntry,NumericEntry</description></item>
+    ///     <item><description>SortedSetEntry --&gt; EntryType,BinaryEntry,NumericEntry,NumericEntry</description></item>
+    ///     <item><description>FieldNumber,PackedVersion,MinLength,MaxLength,BlockSize,ValueCount
--&gt; VInt (<see cref="Store.DataOutput.WriteVInt32(int)"/></description></item>
+    ///     <item><description>EntryType,CompressionType --&gt; Byte (<see
cref="Store.DataOutput.WriteByte(byte)"/></description></item>
+    ///     <item><description>Header --&gt; CodecHeader (<see cref="CodecUtil.WriteHeader(Store.DataOutput,
string, int)"/>) </description></item>
+    ///     <item><description>MinValue,GCD,MissingOffset,AddressOffset,DataOffset
--&gt; Int64 (<see cref="Store.DataOutput.WriteInt64(long)"/>) </description></item>
+    ///     <item><description>TableSize --&gt; vInt (<see cref="Store.DataOutput.WriteVInt32(int)"/>)
</description></item>
+    ///     <item><description>Footer --&gt; CodecFooter (<see cref="CodecUtil.WriteFooter(Store.IndexOutput)"/>)
</description></item>
+    ///   </list>
+    ///   <para>Sorted fields have two entries: a <see cref="Lucene45DocValuesProducer.BinaryEntry"/>
with the value metadata,
+    ///      and an ordinary <see cref="Lucene45DocValuesProducer.NumericEntry"/> for
the document-to-ord metadata.</para>
+    ///   <para>SortedSet fields have three entries: a <see cref="Lucene45DocValuesProducer.BinaryEntry"/>
with the value metadata,
+    ///      and two <see cref="Lucene45DocValuesProducer.NumericEntry"/>s for the
document-to-ord-index and ordinal list metadata.</para>
+    ///   <para>FieldNumber of -1 indicates the end of metadata.</para>
+    ///   <para>EntryType is a 0 (<see cref="Lucene45DocValuesProducer.NumericEntry"/>)
or 1 (<see cref="Lucene45DocValuesProducer.BinaryEntry"/>)</para>
+    ///   <para>DataOffset is the pointer to the start of the data in the DocValues
data (.dvd)</para>
+    ///   <para/>NumericType indicates how Numeric values will be compressed:
+    ///      <list type="bullet">
+    ///         <item><description>0 --&gt; delta-compressed. For each block
of 16k integers, every integer is delta-encoded
+    ///             from the minimum value within the block.</description></item>
+    ///         <item><description>1 --&gt; gcd-compressed. When all integers
share a common divisor, only quotients are stored
+    ///             using blocks of delta-encoded ints.</description></item>
+    ///         <item><description>2 --&gt; table-compressed. When the number
of unique numeric values is small and it would save space,
+    ///             a lookup table of unique values is written, followed by the ordinal for
each document.</description></item>
+    ///      </list>
+    ///   <para/>BinaryType indicates how Binary values will be stored:
+    ///      <list type="bullet">
+    ///         <item><description>0 --&gt; fixed-width. All values have
the same length, addressing by multiplication.</description></item>
+    ///         <item><description>1 --&gt; variable-width. An address for
each value is stored.</description></item>
+    ///         <item><description>2 --&gt; prefix-compressed. An address
to the start of every interval'th value is stored.</description></item>
+    ///      </list>
+    ///   <para/>MinLength and MaxLength represent the min and max byte[] value lengths
for Binary values.
     ///      If they are equal, then all values are of a fixed size, and can be addressed
as DataOffset + (docID * length).
     ///      Otherwise, the binary values are of variable size, and packed integer metadata
(PackedVersion,BlockSize)
     ///      is written for the addresses.
-    ///   <p>MissingOffset points to a byte[] containing a bitset of all documents
that had a value for the field.
+    ///   <para/>MissingOffset points to a <see cref="T:byte[]"/> containing
a bitset of all documents that had a value for the field.
     ///      If its -1, then there are no missing values.
-    ///   <p>Checksum contains the CRC32 checksum of all bytes in the .dvm file up
+    ///   <para/>Checksum contains the CRC32 checksum of all bytes in the .dvm file
up
     ///      until the checksum. this is used to verify integrity of the file on opening
the
-    ///      index.
-    ///   <li><a name="dvd" id="dvd"></a>
-    ///   <p>The DocValues data or .dvd file.</p>
-    ///   <p>For DocValues field, this stores the actual per-document data (the heavy-lifting)</p>
-    ///   <p>DocValues data (.dvd) --&gt; Header,&lt;NumericData | BinaryData
| SortedData&gt;<sup>NumFields</sup>,Footer</p>
-    ///   <ul>
-    ///     <li>NumericData --&gt; DeltaCompressedNumerics | TableCompressedNumerics
| GCDCompressedNumerics</li>
-    ///     <li>BinaryData --&gt;  <seealso cref="DataOutput#writeByte Byte"/><sup>DataLength</sup>,Addresses</li>
-    ///     <li>SortedData --&gt; <seealso cref="FST FST&lt;Int64&gt;"/></li>
-    ///     <li>DeltaCompressedNumerics --&gt; <seealso cref="BlockPackedWriter
BlockPackedInts(blockSize=16k)"/></li>
-    ///     <li>TableCompressedNumerics --&gt; <seealso cref="PackedInts PackedInts"/></li>
-    ///     <li>GCDCompressedNumerics --&gt; <seealso cref="BlockPackedWriter
BlockPackedInts(blockSize=16k)"/></li>
-    ///     <li>Addresses --&gt; <seealso cref="MonotonicBlockPackedWriter MonotonicBlockPackedInts(blockSize=16k)"/></li>
-    ///     <li>Footer --&gt; <seealso cref="CodecUtil#writeFooter CodecFooter"/></li>
-    ///   </ul>
-    ///   <p>SortedSet entries store the list of ordinals in their BinaryData as a
-    ///      sequences of increasing <seealso cref="DataOutput#writeVLong vLong"/>s,
delta-encoded.</p>
-    /// </ol>
+    ///      index.</description></item>
+    ///   <item><description><a name="dvd" id="dvd"></a>
+    ///   <para>The DocValues data or .dvd file.</para>
+    ///   <para>For DocValues field, this stores the actual per-document data (the
heavy-lifting)</para>
+    ///   <para>DocValues data (.dvd) --&gt; Header,&lt;NumericData | BinaryData
| SortedData&gt;<sup>NumFields</sup>,Footer</para>
+    ///   <list type="bullet">
+    ///     <item><description>NumericData --&gt; DeltaCompressedNumerics
| TableCompressedNumerics | GCDCompressedNumerics</description></item>
+    ///     <item><description>BinaryData --&gt;  Byte (<see cref="Store.DataOutput.WriteByte(byte)"/>)
<sup>DataLength</sup>,Addresses</description></item>
+    ///     <item><description>SortedData --&gt; FST&lt;Int64&gt;
(<see cref="Util.Fst.FST{T}"/>) </description></item>
+    ///     <item><description>DeltaCompressedNumerics --&gt; BlockPackedInts(blockSize=16k)
(<see cref="Util.Packed.BlockPackedWriter"/>) </description></item>
+    ///     <item><description>TableCompressedNumerics --&gt; PackedInts
(<see cref="Util.Packed.PackedInt32s"/>) </description></item>
+    ///     <item><description>GCDCompressedNumerics --&gt; BlockPackedInts(blockSize=16k)
(<see cref="Util.Packed.BlockPackedWriter"/>) </description></item>
+    ///     <item><description>Addresses --&gt; MonotonicBlockPackedInts(blockSize=16k)
(<see cref="Util.Packed.MonotonicBlockPackedWriter"/>) </description></item>
+    ///     <item><description>Footer --&gt; CodecFooter (<see cref="CodecUtil.WriteFooter(Store.IndexOutput)"/>)
</description></item>
+    ///   </list>
+    ///   <para>SortedSet entries store the list of ordinals in their BinaryData as
a
+    ///      sequences of increasing vLongs (<see cref="Store.DataOutput.WriteVInt64(long)"/>),
delta-encoded.</para></description></item>
+    /// </list>
+    /// <para/>
     /// @lucene.experimental
     /// </summary>
     [DocValuesFormatName("Lucene45")] // LUCENENET specific - using DocValuesFormatName attribute
to ensure the default name passed from subclasses is the same as this class name

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/b27d10c3/src/Lucene.Net/Codecs/Lucene45/Lucene45DocValuesProducer.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Codecs/Lucene45/Lucene45DocValuesProducer.cs b/src/Lucene.Net/Codecs/Lucene45/Lucene45DocValuesProducer.cs
index 025af22..300b1cf 100644
--- a/src/Lucene.Net/Codecs/Lucene45/Lucene45DocValuesProducer.cs
+++ b/src/Lucene.Net/Codecs/Lucene45/Lucene45DocValuesProducer.cs
@@ -49,7 +49,7 @@ namespace Lucene.Net.Codecs.Lucene45
     using TermsEnum = Lucene.Net.Index.TermsEnum;
 
     /// <summary>
-    /// reader for <seealso cref="Lucene45DocValuesFormat"/> </summary>
+    /// Reader for <see cref="Lucene45DocValuesFormat"/>. </summary>
     public class Lucene45DocValuesProducer : DocValuesProducer, IDisposable
     {
         private readonly IDictionary<int, NumericEntry> numerics;
@@ -68,7 +68,7 @@ namespace Lucene.Net.Codecs.Lucene45
         private readonly IDictionary<int, MonotonicBlockPackedReader> ordIndexInstances
= new Dictionary<int, MonotonicBlockPackedReader>();
 
         /// <summary>
-        /// expert: instantiates a new reader </summary>
+        /// Expert: instantiates a new reader. </summary>
         protected internal Lucene45DocValuesProducer(SegmentReadState state, string dataCodec,
string dataExtension, string metaCodec, string metaExtension)
         {
             string metaName = IndexFileNames.SegmentFileName(state.SegmentInfo.Name, state.SegmentSuffix,
metaExtension);
@@ -502,8 +502,9 @@ namespace Lucene.Net.Codecs.Lucene45
         }
 
         /// <summary>
-        /// returns an address instance for variable-length binary values.
-        ///  @lucene.internal
+        /// Returns an address instance for variable-length binary values.
+        /// <para/>
+        /// @lucene.internal
         /// </summary>
         protected internal virtual MonotonicBlockPackedReader GetAddressInstance(IndexInput
data, FieldInfo field, BinaryEntry bytes)
         {
@@ -572,7 +573,8 @@ namespace Lucene.Net.Codecs.Lucene45
         }
 
         /// <summary>
-        /// returns an address instance for prefix-compressed binary values.
+        /// Returns an address instance for prefix-compressed binary values.
+        /// <para/>
         /// @lucene.internal
         /// </summary>
         protected internal virtual MonotonicBlockPackedReader GetIntervalInstance(IndexInput
data, FieldInfo field, BinaryEntry bytes)
@@ -684,7 +686,8 @@ namespace Lucene.Net.Codecs.Lucene45
         }
 
         /// <summary>
-        /// returns an address instance for sortedset ordinal lists
+        /// Returns an address instance for sortedset ordinal lists.
+        /// <para/>
         /// @lucene.internal
         /// </summary>
         protected internal virtual MonotonicBlockPackedReader GetOrdIndexInstance(IndexInput
data, FieldInfo field, NumericEntry entry)
@@ -895,7 +898,7 @@ namespace Lucene.Net.Codecs.Lucene45
         }
 
         /// <summary>
-        /// metadata entry for a numeric docvalues field </summary>
+        /// Metadata entry for a numeric docvalues field. </summary>
         protected internal class NumericEntry
         {
             internal NumericEntry()
@@ -903,28 +906,28 @@ namespace Lucene.Net.Codecs.Lucene45
             }
 
             /// <summary>
-            /// offset to the bitset representing docsWithField, or -1 if no documents have
missing values </summary>
+            /// Offset to the bitset representing docsWithField, or -1 if no documents have
missing values. </summary>
             internal long missingOffset;
 
             /// <summary>
-            /// offset to the actual numeric values </summary>
+            /// Offset to the actual numeric values. </summary>
             public long Offset { get; set; }
 
             internal int format;
 
             /// <summary>
-            /// packed ints version used to encode these numerics 
+            /// Packed <see cref="int"/>s version used to encode these numerics. 
             /// <para/>
             /// NOTE: This was packedIntsVersion (field) in Lucene
             /// </summary>
             public int PackedInt32sVersion { get; set; }
 
             /// <summary>
-            /// count of values written </summary>
+            /// Count of values written. </summary>
             public long Count { get; set; }
 
             /// <summary>
-            /// packed ints blocksize </summary>
+            /// Packed <see cref="int"/>s blocksize. </summary>
             public int BlockSize { get; set; }
 
             internal long minValue;
@@ -933,7 +936,7 @@ namespace Lucene.Net.Codecs.Lucene45
         }
 
         /// <summary>
-        /// metadata entry for a binary docvalues field </summary>
+        /// Metadata entry for a binary docvalues field. </summary>
         protected internal class BinaryEntry
         {
             internal BinaryEntry()
@@ -941,44 +944,44 @@ namespace Lucene.Net.Codecs.Lucene45
             }
 
             /// <summary>
-            /// offset to the bitset representing docsWithField, or -1 if no documents have
missing values </summary>
+            /// Offset to the bitset representing docsWithField, or -1 if no documents have
missing values. </summary>
             internal long missingOffset;
 
             /// <summary>
-            /// offset to the actual binary values </summary>
+            /// Offset to the actual binary values. </summary>
             internal long offset;
 
             internal int format;
 
             /// <summary>
-            /// count of values written </summary>
+            /// Count of values written. </summary>
             public long Count { get; set; }
 
             internal int minLength;
             internal int maxLength;
 
             /// <summary>
-            /// offset to the addressing data that maps a value to its slice of the byte[]
</summary>
+            /// Offset to the addressing data that maps a value to its slice of the <see
cref="T:byte[]"/>. </summary>
             public long AddressesOffset { get; set; }
 
             /// <summary>
-            /// interval of shared prefix chunks (when using prefix-compressed binary) </summary>
+            /// Interval of shared prefix chunks (when using prefix-compressed binary). </summary>
             public long AddressInterval { get; set; }
 
             /// <summary>
-            /// packed ints version used to encode addressing information 
+            /// Packed ints version used to encode addressing information.
             /// <para/>
-            /// NOTE: This was packedIntsVersion (field) in Lucene
+            /// NOTE: This was packedIntsVersion (field) in Lucene.
             /// </summary>
             public int PackedInt32sVersion { get; set; }
 
             /// <summary>
-            /// packed ints blocksize </summary>
+            /// Packed ints blocksize. </summary>
             public int BlockSize { get; set; }
         }
 
         /// <summary>
-        /// metadata entry for a sorted-set docvalues field </summary>
+        /// Metadata entry for a sorted-set docvalues field. </summary>
         protected internal class SortedSetEntry
         {
             internal SortedSetEntry()
@@ -990,7 +993,7 @@ namespace Lucene.Net.Codecs.Lucene45
 
         // internally we compose complex dv (sorted/sortedset) from other ones
         /// <summary>
-        /// NOTE: This was LongBinaryDocValues in Lucene
+        /// NOTE: This was LongBinaryDocValues in Lucene.
         /// </summary>
         internal abstract class Int64BinaryDocValues : BinaryDocValues
         {


Mime
View raw message