lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From nightowl...@apache.org
Subject [09/21] lucenenet git commit: Lucene.Net.Core.Document: Cleaned up documentation comments
Date Sun, 12 Mar 2017 16:38:08 GMT
Lucene.Net.Core.Document: Cleaned up documentation comments


Project: http://git-wip-us.apache.org/repos/asf/lucenenet/repo
Commit: http://git-wip-us.apache.org/repos/asf/lucenenet/commit/117429e8
Tree: http://git-wip-us.apache.org/repos/asf/lucenenet/tree/117429e8
Diff: http://git-wip-us.apache.org/repos/asf/lucenenet/diff/117429e8

Branch: refs/heads/api-work
Commit: 117429e8a1aafa569d5823271349221645392664
Parents: c7e011f
Author: Shad Storhaug <shad@shadstorhaug.com>
Authored: Sun Mar 12 01:33:10 2017 +0700
Committer: Shad Storhaug <shad@shadstorhaug.com>
Committed: Sun Mar 12 01:33:10 2017 +0700

----------------------------------------------------------------------
 .../Document/BinaryDocValuesField.cs            |  22 +-
 .../Document/ByteDocValuesField.cs              |  19 +-
 .../Document/CompressionTools.cs                |  45 ++--
 src/Lucene.Net.Core/Document/DateTools.cs       |  82 +++----
 .../Document/DerefBytesDocValuesField.cs        |  27 +--
 src/Lucene.Net.Core/Document/Document.cs        |  83 ++++----
 .../Document/DocumentStoredFieldVisitor.cs      |  17 +-
 .../Document/DoubleDocValuesField.cs            |  19 +-
 src/Lucene.Net.Core/Document/DoubleField.cs     | 136 ++++++------
 src/Lucene.Net.Core/Document/Field.cs           | 211 ++++++++++---------
 src/Lucene.Net.Core/Document/FieldType.cs       | 126 ++++++-----
 .../Document/FloatDocValuesField.cs             |  10 +-
 src/Lucene.Net.Core/Document/FloatField.cs      | 140 ++++++------
 .../Document/IntDocValuesField.cs               |  12 +-
 src/Lucene.Net.Core/Document/IntField.cs        | 139 ++++++------
 .../Document/LongDocValuesField.cs              |  22 +-
 src/Lucene.Net.Core/Document/LongField.cs       | 151 ++++++-------
 .../Document/NumericDocValuesField.cs           |  18 +-
 .../Document/PackedLongDocValuesField.cs        |  23 +-
 .../Document/ShortDocValuesField.cs             |  23 +-
 .../Document/SortedBytesDocValuesField.cs       |  31 +--
 .../Document/SortedDocValuesField.cs            |  20 +-
 .../Document/SortedSetDocValuesField.cs         |  24 +--
 src/Lucene.Net.Core/Document/StoredField.cs     |  61 +++---
 .../Document/StraightBytesDocValuesField.cs     |  31 ++-
 src/Lucene.Net.Core/Document/StringField.cs     |  22 +-
 src/Lucene.Net.Core/Document/TextField.cs       |  27 ++-
 27 files changed, 784 insertions(+), 757 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/lucenenet/blob/117429e8/src/Lucene.Net.Core/Document/BinaryDocValuesField.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Document/BinaryDocValuesField.cs b/src/Lucene.Net.Core/Document/BinaryDocValuesField.cs
index e62db55..59df369 100644
--- a/src/Lucene.Net.Core/Document/BinaryDocValuesField.cs
+++ b/src/Lucene.Net.Core/Document/BinaryDocValuesField.cs
@@ -21,25 +21,25 @@ namespace Lucene.Net.Documents
      */
 
     /// <summary>
-    /// Field that stores a per-document <seealso cref="BytesRef"/> value.
-    /// 
+    /// Field that stores a per-document <see cref="BytesRef"/> value.
+    /// <para/>
     /// The values are stored directly with no sharing, which is a good fit when
     /// the fields don't share (many) values, such as a title field.  If values
-    /// may be shared and sorted it's better to use <seealso cref="SortedDocValuesField"/>.
+    /// may be shared and sorted it's better to use <see cref="SortedDocValuesField"/>.
     /// Here's an example usage:
     ///
-    /// <pre class="prettyprint">
-    ///   document.add(new BinaryDocValuesField(name, new BytesRef("hello")));
-    /// </pre>
-    ///
+    /// <code>
+    ///   document.Add(new BinaryDocValuesField(name, new BytesRef("hello")));
+    /// </code>
+    /// <para/>
     /// If you also need to store the value, you should add a
-    /// separate <seealso cref="StoredField"/> instance.
+    /// separate <see cref="StoredField"/> instance.
     /// </summary>
     /// <seealso cref="BinaryDocValues"/>
     public class BinaryDocValuesField : Field
     {
         /// <summary>
-        /// Type for straight bytes DocValues.
+        /// Type for straight bytes <see cref="DocValues"/>.
         /// </summary>
         public static readonly FieldType fType = new FieldType();
 
@@ -50,10 +50,10 @@ namespace Lucene.Net.Documents
         }
 
         /// <summary>
-        /// Create a new binary DocValues field. </summary>
+        /// Create a new binary <see cref="DocValues"/> field. </summary>
         /// <param name="name"> field name </param>
         /// <param name="value"> binary content </param>
-        /// <exception cref="ArgumentNullException"> if the field name is null </exception>
+        /// <exception cref="System.ArgumentNullException"> if the field name is null </exception>
         public BinaryDocValuesField(string name, BytesRef value)
             : base(name, fType)
         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/117429e8/src/Lucene.Net.Core/Document/ByteDocValuesField.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Document/ByteDocValuesField.cs b/src/Lucene.Net.Core/Document/ByteDocValuesField.cs
index 211197f..38bfe8d 100644
--- a/src/Lucene.Net.Core/Document/ByteDocValuesField.cs
+++ b/src/Lucene.Net.Core/Document/ByteDocValuesField.cs
@@ -20,25 +20,26 @@ namespace Lucene.Net.Documents
      */
 
     /// <summary>
-    /// Field that stores a per-document <code>byte</code> value for scoring,
+    /// Field that stores a per-document <see cref="byte"/> value for scoring,
     /// sorting or value retrieval. Here's an example usage:
     ///
-    /// <pre class="prettyprint">
-    ///   document.add(new ByteDocValuesField(name, (byte) 22));
-    /// </pre>
-    ///
+    /// <code>
+    ///   document.Add(new ByteDocValuesField(name, (byte) 22));
+    /// </code>
+    /// 
+    /// <para/>
     /// If you also need to store the value, you should add a
-    /// separate <seealso cref="StoredField"/> instance.
+    /// separate <see cref="StoredField"/> instance.
     /// </summary>
-    /// <seealso cref="NumericDocValues"/>
+    /// <seealso cref="NumericDocValuesField"/>
     [Obsolete("Use NumericDocValuesField instead")]
     public class ByteDocValuesField : NumericDocValuesField
     {
         /// <summary>
-        /// Creates a new DocValues field with the specified 8-bit byte value </summary>
+        /// Creates a new <see cref="Index.DocValues"/> field with the specified 8-bit byte value </summary>
         /// <param name="name"> field name </param>
         /// <param name="value"> 8-bit byte value </param>
-        /// <exception cref="IllegalArgumentException"> if the field name is null. </exception>
+        /// <exception cref="ArgumentNullException"> if the field name is null. </exception>
         public ByteDocValuesField(string name, byte value)
             : base(name, value)
         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/117429e8/src/Lucene.Net.Core/Document/CompressionTools.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Document/CompressionTools.cs b/src/Lucene.Net.Core/Document/CompressionTools.cs
index c8bca94..d5324f4 100644
--- a/src/Lucene.Net.Core/Document/CompressionTools.cs
+++ b/src/Lucene.Net.Core/Document/CompressionTools.cs
@@ -23,11 +23,10 @@ namespace Lucene.Net.Documents
 
     /// <summary>
     /// Simple utility class providing static methods to
-    ///  compress and decompress binary data for stored fields.
-    ///  this class uses java.util.zip.Deflater and Inflater
-    ///  classes to compress and decompress.
+    /// compress and decompress binary data for stored fields.
+    /// this class uses the <see cref="System.IO.Compression.DeflateStream"/>
+    /// class to compress and decompress.
     /// </summary>
-
     public class CompressionTools
     {
         // Export only static methods
@@ -36,8 +35,8 @@ namespace Lucene.Net.Documents
         }
 
         /// <summary>
-        /// Compresses the specified byte range using the
-        ///  specified compressionLevel 
+        /// Compresses the specified <see cref="byte"/> range using the
+        /// specified <paramref name="compressionLevel"/>.
         /// </summary>
         public static byte[] Compress(byte[] value, int offset, int length, CompressionLevel compressionLevel)
         {
@@ -55,7 +54,7 @@ namespace Lucene.Net.Documents
         }
 
         /// <summary>
-        /// Compresses the specified byte range, with default Optimal level 
+        /// Compresses the specified <see cref="byte"/> range, with default <see cref="CompressionLevel.Optimal"/> level 
         /// </summary>
         public static byte[] Compress(byte[] value, int offset, int length)
         {
@@ -63,22 +62,22 @@ namespace Lucene.Net.Documents
         }
 
         /// <summary>
-        /// Compresses all bytes in the array, with default Optimal level </summary>
+        /// Compresses all <see cref="byte"/>s in the array, with default <see cref="CompressionLevel.Optimal"/> level </summary>
         public static byte[] Compress(byte[] value)
         {
             return Compress(value, 0, value.Length, CompressionLevel.Optimal);
         }
 
         /// <summary>
-        /// Compresses the String value, with default BEST_COMPRESSION level </summary>
+        /// Compresses the <see cref="string"/> value, with default <see cref="CompressionLevel.Optimal"/> level </summary>
         public static byte[] CompressString(string value)
         {
             return CompressString(value, CompressionLevel.Optimal);
         }
 
         /// <summary>
-        /// Compresses the String value using the specified
-        ///  compressionLevel.
+        /// Compresses the <see cref="string"/> value using the specified
+        /// <paramref name="compressionLevel"/>.
         /// </summary>
         public static byte[] CompressString(string value, CompressionLevel compressionLevel)
         {
@@ -88,8 +87,8 @@ namespace Lucene.Net.Documents
         }
 
         /// <summary>
-        /// Decompress the byte array previously returned by
-        ///  compress (referenced by the provided BytesRef)
+        /// Decompress the <see cref="byte"/> array previously returned by
+        /// compress (referenced by the provided <see cref="BytesRef"/>)
         /// </summary>
         public static byte[] Decompress(BytesRef bytes)
         {
@@ -97,8 +96,8 @@ namespace Lucene.Net.Documents
         }
 
         /// <summary>
-        /// Decompress the byte array previously returned by
-        ///  compress
+        /// Decompress the <see cref="byte"/> array previously returned by
+        /// compress
         /// </summary>
         public static byte[] Decompress(byte[] value)
         {
@@ -106,8 +105,8 @@ namespace Lucene.Net.Documents
         }
 
         /// <summary>
-        /// Decompress the byte array previously returned by
-        ///  compress
+        /// Decompress the <see cref="byte"/> array previously returned by
+        /// compress
         /// </summary>
         public static byte[] Decompress(byte[] value, int offset, int length)
         {
@@ -129,8 +128,8 @@ namespace Lucene.Net.Documents
         }
 
         /// <summary>
-        /// Decompress the byte array previously returned by
-        ///  compressString back into a String
+        /// Decompress the <see cref="byte"/> array previously returned by
+        /// <see cref="CompressString(string)"/> back into a <see cref="string"/>
         /// </summary>
         public static string DecompressString(byte[] value)
         {
@@ -138,8 +137,8 @@ namespace Lucene.Net.Documents
         }
 
         /// <summary>
-        /// Decompress the byte array previously returned by
-        ///  compressString back into a String
+        /// Decompress the <see cref="byte"/> array previously returned by
+        /// <see cref="CompressString(string)"/> back into a <see cref="string"/>
         /// </summary>
         public static string DecompressString(byte[] value, int offset, int length)
         {
@@ -150,8 +149,8 @@ namespace Lucene.Net.Documents
         }
 
         /// <summary>
-        /// Decompress the byte array (referenced by the provided BytesRef)
-        ///  previously returned by compressString back into a String
+        /// Decompress the <see cref="byte"/> array (referenced by the provided <see cref="BytesRef"/>)
+        /// previously returned by <see cref="CompressString(string)"/> back into a <see cref="string"/>
         /// </summary>
         public static string DecompressString(BytesRef bytes)
         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/117429e8/src/Lucene.Net.Core/Document/DateTools.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Document/DateTools.cs b/src/Lucene.Net.Core/Document/DateTools.cs
index 7154124..2edfe7f 100644
--- a/src/Lucene.Net.Core/Document/DateTools.cs
+++ b/src/Lucene.Net.Core/Document/DateTools.cs
@@ -25,18 +25,18 @@ namespace Lucene.Net.Documents
     /// them by date, which makes them suitable for use as field values
     /// and search terms.
     ///
-    /// <P>this class also helps you to limit the resolution of your dates. Do not
+    /// <para/>This class also helps you to limit the resolution of your dates. Do not
     /// save dates with a finer resolution than you really need, as then
-    /// <seealso cref="TermRangeQuery"/> and <seealso cref="PrefixQuery"/> will require more memory and become slower.
+    /// <see cref="Search.TermRangeQuery"/> and <see cref="Search.PrefixQuery"/> will require more memory and become slower.
     ///
-    /// <P>
-    /// Another approach is <seealso cref="NumericUtils"/>, which provides
+    /// <para/>
+    /// Another approach is <see cref="Util.NumericUtils"/>, which provides
     /// a sortable binary representation (prefix encoded) of numeric values, which
     /// date/time are.
-    /// For indexing a <seealso cref="Date"/> or <seealso cref="Calendar"/>, just get the unix timestamp as
-    /// <code>long</code> using <seealso cref="Date#getTime"/> or <seealso cref="Calendar#getTimeInMillis"/> and
-    /// index this as a numeric value with <seealso cref="Int64Field"/>
-    /// and use <seealso cref="NumericRangeQuery"/> to query it.
+    /// 
+    /// For indexing a <see cref="DateTime"/>, just get the <see cref="DateTime.Ticks"/> and index
+    /// this as a numeric value with <see cref="Int64Field"/> and use <see cref="Search.NumericRangeQuery{T}"/>
+    /// to query it.
     /// </summary>
     public static class DateTools
     {
@@ -48,16 +48,17 @@ namespace Lucene.Net.Documents
         private static readonly string SECOND_FORMAT = "yyyyMMddHHmmss";
         private static readonly string MILLISECOND_FORMAT = "yyyyMMddHHmmssfff";
 
-        private static readonly System.Globalization.Calendar calInstance = new System.Globalization.GregorianCalendar();
+        // LUCENENET - not used
+        //private static readonly System.Globalization.Calendar calInstance = new System.Globalization.GregorianCalendar();
 
         /// <summary>
-        /// Converts a Date to a string suitable for indexing.
+        /// Converts a <see cref="DateTime"/> to a string suitable for indexing.
         /// </summary>
         /// <param name="date"> the date to be converted </param>
         /// <param name="resolution"> the desired resolution, see
-        ///  <seealso cref="#round(Date, DateTools.Resolution)"/> </param>
-        /// <returns> a string in format <code>yyyyMMddHHmmssSSS</code> or shorter,
-        ///  depending on <code>resolution</code>; using GMT as timezone  </returns>
+        /// <see cref="Round(DateTime, DateTools.Resolution)"/> </param>
+        /// <returns> a string in format <c>yyyyMMddHHmmssSSS</c> or shorter,
+        /// depending on <paramref name="resolution"/>; using GMT as timezone  </returns>
         public static string DateToString(DateTime date, Resolution resolution)
         {
             return TimeToString(date.Ticks / TimeSpan.TicksPerMillisecond, resolution);
@@ -66,11 +67,11 @@ namespace Lucene.Net.Documents
         /// <summary>
         /// Converts a millisecond time to a string suitable for indexing.
         /// </summary>
-        /// <param name="time"> the date expressed as milliseconds since January 1, 1970, 00:00:00 GMT </param>
+        /// <param name="time"> the date expressed as milliseconds since January 1, 1970, 00:00:00 GMT (also known as the "epoch") </param>
         /// <param name="resolution"> the desired resolution, see
-        ///  <seealso cref="#round(long, DateTools.Resolution)"/> </param>
-        /// <returns> a string in format <code>yyyyMMddHHmmssSSS</code> or shorter,
-        ///  depending on <code>resolution</code>; using GMT as timezone </returns>
+        /// <see cref="Round(long, DateTools.Resolution)"/> </param>
+        /// <returns> a string in format <c>yyyyMMddHHmmssSSS</c> or shorter,
+        /// depending on <paramref name="resolution"/>; using GMT as timezone </returns>
         public static string TimeToString(long time, Resolution resolution)
         {
             DateTime date = new DateTime(Round(time, resolution));
@@ -108,28 +109,28 @@ namespace Lucene.Net.Documents
         }
 
         /// <summary>
-        /// Converts a string produced by <code>timeToString</code> or
-        /// <code>dateToString</code> back to a time, represented as the
-        /// number of milliseconds since January 1, 1970, 00:00:00 GMT.
+        /// Converts a string produced by <see cref="TimeToString(long, Resolution)"/> or
+        /// <see cref="DateToString(DateTime, Resolution)"/> back to a time, represented as the
+        /// number of milliseconds since January 1, 1970, 00:00:00 GMT (also known as the "epoch").
         /// </summary>
         /// <param name="dateString"> the date string to be converted </param>
-        /// <returns> the number of milliseconds since January 1, 1970, 00:00:00 GMT </returns>
-        /// <exception cref="ParseException"> if <code>dateString</code> is not in the
-        ///  expected format  </exception>
+        /// <returns> the number of milliseconds since January 1, 1970, 00:00:00 GMT (also known as the "epoch")</returns>
+        /// <exception cref="FormatException"> if <paramref name="dateString"/> is not in the
+        /// expected format </exception>
         public static long StringToTime(string dateString)
         {
             return StringToDate(dateString).Ticks;
         }
 
         /// <summary>
-        /// Converts a string produced by <code>timeToString</code> or
-        /// <code>dateToString</code> back to a time, represented as a
-        /// Date object.
+        /// Converts a string produced by <see cref="TimeToString(long, Resolution)"/> or
+        /// <see cref="DateToString(DateTime, Resolution)"/> back to a time, represented as a
+        /// <see cref="DateTime"/> object.
         /// </summary>
         /// <param name="dateString"> the date string to be converted </param>
-        /// <returns> the parsed time as a Date object </returns>
-        /// <exception cref="ParseException"> if <code>dateString</code> is not in the
-        ///  expected format  </exception>
+        /// <returns> the parsed time as a <see cref="DateTime"/> object </returns>
+        /// <exception cref="FormatException"> if <paramref name="dateString"/> is not in the
+        /// expected format </exception>
         public static DateTime StringToDate(string dateString)
         {
             DateTime date;
@@ -196,27 +197,30 @@ namespace Lucene.Net.Documents
         }
 
         /// <summary>
-        /// Limit a date's resolution. For example, the date <code>2004-09-21 13:50:11</code>
-        /// will be changed to <code>2004-09-01 00:00:00</code> when using
-        /// <code>Resolution.MONTH</code>.
+        /// Limit a date's resolution. For example, the date <c>2004-09-21 13:50:11</c>
+        /// will be changed to <c>2004-09-01 00:00:00</c> when using
+        /// <see cref="Resolution.MONTH"/>.
         /// </summary>
+        /// <param name="date"> the date to be rounded </param>
         /// <param name="resolution"> The desired resolution of the date to be returned </param>
-        /// <returns> the date with all values more precise than <code>resolution</code>
-        ///  set to 0 or 1 </returns>
+        /// <returns> the date with all values more precise than <paramref name="resolution"/>
+        /// set to 0 or 1 </returns>
         public static DateTime Round(DateTime date, Resolution resolution)
         {
             return new DateTime(Round(date.Ticks / TimeSpan.TicksPerMillisecond, resolution));
         }
 
         /// <summary>
-        /// Limit a date's resolution. For example, the date <code>1095767411000</code>
+        /// Limit a date's resolution. For example, the date <c>1095767411000</c>
         /// (which represents 2004-09-21 13:50:11) will be changed to
-        /// <code>1093989600000</code> (2004-09-01 00:00:00) when using
-        /// <code>Resolution.MONTH</code>.
+        /// <c>1093989600000</c> (2004-09-01 00:00:00) when using
+        /// <see cref="Resolution.MONTH"/>.
         /// </summary>
+        /// <param name="time"> the time to be rounded </param>
         /// <param name="resolution"> The desired resolution of the date to be returned </param>
-        /// <returns> the date with all values more precise than <code>resolution</code>
-        ///  set to 0 or 1, expressed as milliseconds since January 1, 1970, 00:00:00 GMT </returns>
+        /// <returns> the date with all values more precise than <paramref name="resolution"/>
+        /// set to 0 or 1, expressed as milliseconds since January 1, 1970, 00:00:00 GMT 
+        /// (also known as the "epoch")</returns>
         public static long Round(long time, Resolution resolution)
         {
             DateTime dt = new DateTime(time * TimeSpan.TicksPerMillisecond);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/117429e8/src/Lucene.Net.Core/Document/DerefBytesDocValuesField.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Document/DerefBytesDocValuesField.cs b/src/Lucene.Net.Core/Document/DerefBytesDocValuesField.cs
index 3c38148..4032ce9 100644
--- a/src/Lucene.Net.Core/Document/DerefBytesDocValuesField.cs
+++ b/src/Lucene.Net.Core/Document/DerefBytesDocValuesField.cs
@@ -22,46 +22,47 @@ namespace Lucene.Net.Documents
 
     /// <summary>
     /// Field that stores
-    /// a per-document <seealso cref="BytesRef"/> value. Here's an example usage:
+    /// a per-document <see cref="BytesRef"/> value. Here's an example usage:
     ///
-    /// <pre class="prettyprint">
-    ///   document.add(new DerefBytesDocValuesField(name, new BytesRef("hello")));
-    /// </pre>
+    /// <code>
+    ///   document.Add(new DerefBytesDocValuesField(name, new BytesRef("hello")));
+    /// </code>
     ///
+    /// <para/>
     /// If you also need to store the value, you should add a
-    /// separate <seealso cref="StoredField"/> instance.
+    /// separate <see cref="StoredField"/> instance.
     /// </summary>
-    /// <seealso cref="BinaryDocValues"/>
+    /// <seealso cref="Index.BinaryDocValues"/>
     [Obsolete("Use BinaryDocValuesField instead.")]
     public class DerefBytesDocValuesField : BinaryDocValuesField
     {
         /// <summary>
-        /// Type for bytes DocValues: all with the same length
+        /// Type for bytes <see cref="Index.DocValues"/>: all with the same length
         /// </summary>
         public static readonly FieldType TYPE_FIXED_LEN = BinaryDocValuesField.fType;
 
         /// <summary>
-        /// Type for bytes DocValues: can have variable lengths
+        /// Type for bytes <see cref="Index.DocValues"/>: can have variable lengths
         /// </summary>
         public static readonly FieldType TYPE_VAR_LEN = BinaryDocValuesField.fType;
 
         /// <summary>
-        /// Create a new fixed or variable-length DocValues field. </summary>
+        /// Create a new fixed or variable-length <see cref="Index.DocValues"/> field. </summary>
         /// <param name="name"> field name </param>
         /// <param name="bytes"> binary content </param>
-        /// <exception cref="IllegalArgumentException"> if the field name is null </exception>
+        /// <exception cref="ArgumentNullException"> if the field name is null </exception>
         public DerefBytesDocValuesField(string name, BytesRef bytes)
             : base(name, bytes)
         {
         }
 
         /// <summary>
-        /// Create a new fixed or variable length DocValues field.
-        /// <p> </summary>
+        /// Create a new fixed or variable length <see cref="Index.DocValues"/> field.
+        /// </summary>
         /// <param name="name"> field name </param>
         /// <param name="bytes"> binary content </param>
         /// <param name="isFixedLength"> (ignored) </param>
-        /// <exception cref="IllegalArgumentException"> if the field name is null </exception>
+        /// <exception cref="ArgumentNullException"> if the field name is null </exception>
         public DerefBytesDocValuesField(string name, BytesRef bytes, bool isFixedLength)
             : base(name, bytes)
         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/117429e8/src/Lucene.Net.Core/Document/Document.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Document/Document.cs b/src/Lucene.Net.Core/Document/Document.cs
index 12a8168..02fb340 100644
--- a/src/Lucene.Net.Core/Document/Document.cs
+++ b/src/Lucene.Net.Core/Document/Document.cs
@@ -26,16 +26,16 @@ namespace Lucene.Net.Documents
 
     /// <summary>
     /// Documents are the unit of indexing and search.
-    ///
+    /// <para/>
     /// A Document is a set of fields.  Each field has a name and a textual value.
-    /// A field may be <seealso cref="Lucene.Net.Index.IIndexableFieldType#stored() stored"/> with the document, in which
+    /// A field may be stored (<see cref="IIndexableFieldType.IsStored"/>) with the document, in which
     /// case it is returned with search hits on the document.  Thus each document
     /// should typically contain one or more stored fields which uniquely identify
     /// it.
-    ///
-    /// <p>Note that fields which are <i>not</i> <seealso cref="Lucene.Net.Index.IIndexableFieldType#stored() stored"/> are
-    /// <i>not</i> available in documents retrieved from the index, e.g. with {@link
-    /// ScoreDoc#doc} or <seealso cref="IndexReader#document(int)"/>.</p>
+    /// <para/>
+    /// Note that fields which are <i>not</i> <see cref="Lucene.Net.Index.IIndexableFieldType.IsStored"/> are
+    /// <i>not</i> available in documents retrieved from the index, e.g. with 
+    /// <see cref="Search.ScoreDoc.Doc"/> or <see cref="IndexReader.Document(int)"/>.
     /// </summary>
     public sealed class Document : IEnumerable<IIndexableField>
     {
@@ -58,14 +58,14 @@ namespace Lucene.Net.Documents
         }
 
         /// <summary>
-        /// <p>Adds a field to a document.  Several fields may be added with
+        /// <para>Adds a field to a document.  Several fields may be added with
         /// the same name.  In this case, if the fields are indexed, their text is
-        /// treated as though appended for the purposes of search.</p>
-        /// <p> Note that add like the removeField(s) methods only makes sense
+        /// treated as though appended for the purposes of search.</para>
+        /// <para> Note that add like the <see cref="RemoveField(string)"/> and <see cref="RemoveFields(string)"/> methods only makes sense
         /// prior to adding a document to an index. These methods cannot
         /// be used to change the content of an existing index! In order to achieve this,
         /// a document has to be deleted from an index and a new changed version of that
-        /// document has to be added.</p>
+        /// document has to be added.</para>
         /// </summary>
         public void Add(IIndexableField field)
         {
@@ -73,14 +73,14 @@ namespace Lucene.Net.Documents
         }
 
         /// <summary>
-        /// <p>Removes field with the specified name from the document.
+        /// <para>Removes field with the specified name from the document.
         /// If multiple fields exist with this name, this method removes the first field that has been added.
-        /// If there is no field with the specified name, the document remains unchanged.</p>
-        /// <p> Note that the removeField(s) methods like the add method only make sense
+        /// If there is no field with the specified name, the document remains unchanged.</para>
+        /// <para> Note that the <see cref="RemoveField(string)"/> and <see cref="RemoveFields(string)"/> methods like the add method only make sense
         /// prior to adding a document to an index. These methods cannot
         /// be used to change the content of an existing index! In order to achieve this,
         /// a document has to be deleted from an index and a new changed version of that
-        /// document has to be added.</p>
+        /// document has to be added.</para>
         /// </summary>
         public void RemoveField(string name)
         {
@@ -97,13 +97,13 @@ namespace Lucene.Net.Documents
         }
 
         /// <summary>
-        /// <p>Removes all fields with the given name from the document.
-        /// If there is no field with the specified name, the document remains unchanged.</p>
-        /// <p> Note that the removeField(s) methods like the add method only make sense
+        /// <para>Removes all fields with the given name from the document.
+        /// If there is no field with the specified name, the document remains unchanged.</para>
+        /// <para> Note that the <see cref="RemoveField(string)"/> and <see cref="RemoveFields(string)"/> methods like the add method only make sense
         /// prior to adding a document to an index. These methods cannot
         /// be used to change the content of an existing index! In order to achieve this,
         /// a document has to be deleted from an index and a new changed version of that
-        /// document has to be added.</p>
+        /// document has to be added.</para>
         /// </summary>
         public void RemoveFields(string name)
         {
@@ -120,12 +120,12 @@ namespace Lucene.Net.Documents
 
         /// <summary>
         /// Returns an array of byte arrays for of the fields that have the name specified
-        /// as the method parameter.  this method returns an empty
+        /// as the method parameter. This method returns an empty
         /// array when there are no matching fields.  It never
-        /// returns null.
+        /// returns <c>null</c>.
         /// </summary>
         /// <param name="name"> the name of the field </param>
-        /// <returns> a <code>BytesRef[]</code> of binary field values </returns>
+        /// <returns> a <see cref="T:BytesRef[]"/> of binary field values </returns>
         public BytesRef[] GetBinaryValues(string name)
         {
             var result = new List<BytesRef>();
@@ -148,12 +148,12 @@ namespace Lucene.Net.Documents
 
         /// <summary>
         /// Returns an array of bytes for the first (or only) field that has the name
-        /// specified as the method parameter. this method will return <code>null</code>
+        /// specified as the method parameter. this method will return <c>null</c>
         /// if no binary fields with the specified name are available.
         /// There may be non-binary fields with the same name.
         /// </summary>
         /// <param name="name"> the name of the field. </param>
-        /// <returns> a <code>BytesRef</code> containing the binary field value or <code>null</code> </returns>
+        /// <returns> a <see cref="BytesRef"/> containing the binary field value or <c>null</c> </returns>
         public BytesRef GetBinaryValue(string name)
         {
             foreach (IIndexableField field in fields)
@@ -172,7 +172,7 @@ namespace Lucene.Net.Documents
 
         /// <summary>
         /// Returns a field with the given name if any exist in this document, or
-        /// null.  If multiple fields exists with this name, this method returns the
+        /// <c>null</c>. If multiple fields exists with this name, this method returns the
         /// first value added.
         /// </summary>
         public IIndexableField GetField(string name)
@@ -188,12 +188,12 @@ namespace Lucene.Net.Documents
         }
 
         /// <summary>
-        /// Returns an array of <seealso cref="IIndexableField"/>s with the given name.
+        /// Returns an array of <see cref="IIndexableField"/>s with the given name.
         /// this method returns an empty array when there are no
-        /// matching fields.  It never returns null.
+        /// matching fields. It never returns <c>null</c>.
         /// </summary>
         /// <param name="name"> the name of the field </param>
-        /// <returns> a <code>IndexableField[]</code> array </returns>
+        /// <returns> a <see cref="T:IndexableField[]"/> array </returns>
         public IIndexableField[] GetFields(string name)
         {
             var result = new List<IIndexableField>();
@@ -210,10 +210,11 @@ namespace Lucene.Net.Documents
 
         /// <summary>
         /// Returns a List of all the fields in a document.
-        /// <p>Note that fields which are <i>not</i> stored are
+        /// <para>Note that fields which are <i>not</i> stored are
         /// <i>not</i> available in documents retrieved from the
-        /// index, e.g. <seealso cref="IndexSearcher#doc(int)"/> or {@link
-        /// IndexReader#document(int)}.</p>
+        /// index, e.g. <see cref="Search.IndexSearcher.Doc(int)"/> or 
+        /// <see cref="IndexReader.Document(int)"/>.
+        /// </para>
         /// </summary>
         public IList<IIndexableField> Fields
         {
@@ -227,13 +228,13 @@ namespace Lucene.Net.Documents
 
         /// <summary>
         /// Returns an array of values of the field specified as the method parameter.
-        /// this method returns an empty array when there are no
-        /// matching fields.  It never returns null.
-        /// For <seealso cref="Int32Field"/>, <seealso cref="Int64Field"/>, {@link
-        /// FloatField} and <seealso cref="DoubleField"/> it returns the string value of the number. If you want
-        /// the actual numeric field instances back, use <seealso cref="#getFields"/>. </summary>
+        /// This method returns an empty array when there are no
+        /// matching fields. It never returns <c>null</c>.
+        /// For <see cref="Int32Field"/>, <see cref="Int64Field"/>, 
+        /// <see cref="SingleField"/> and <seealso cref="DoubleField"/> it returns the string value of the number. If you want
+        /// the actual numeric field instances back, use <see cref="GetFields(string)"/>. </summary>
         /// <param name="name"> the name of the field </param>
-        /// <returns> a <code>String[]</code> of field values </returns>
+        /// <returns> a <see cref="T:string[]"/> of field values </returns>
         public string[] GetValues(string name)
         {
             var result = new List<string>();
@@ -255,12 +256,12 @@ namespace Lucene.Net.Documents
 
         /// <summary>
         /// Returns the string value of the field with the given name if any exist in
-        /// this document, or null.  If multiple fields exist with this name, this
+        /// this document, or <c>null</c>.  If multiple fields exist with this name, this
         /// method returns the first value added. If only binary fields with this name
-        /// exist, returns null.
-        /// For <seealso cref="Int32Field"/>, <seealso cref="Int64Field"/>, {@link
-        /// FloatField} and <seealso cref="DoubleField"/> it returns the string value of the number. If you want
-        /// the actual numeric field instance back, use <seealso cref="#getField"/>.
+        /// exist, returns <c>null</c>.
+        /// For <see cref="Int32Field"/>, <see cref="Int64Field"/>, 
+        /// <see cref="SingleField"/> and <seealso cref="DoubleField"/> it returns the string value of the number. If you want
+        /// the actual numeric field instance back, use <see cref="GetField(string)"/>.
         /// </summary>
         public string Get(string name)
         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/117429e8/src/Lucene.Net.Core/Document/DocumentStoredFieldVisitor.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Document/DocumentStoredFieldVisitor.cs b/src/Lucene.Net.Core/Document/DocumentStoredFieldVisitor.cs
index 25e0013..3755784 100644
--- a/src/Lucene.Net.Core/Document/DocumentStoredFieldVisitor.cs
+++ b/src/Lucene.Net.Core/Document/DocumentStoredFieldVisitor.cs
@@ -21,24 +21,23 @@ namespace Lucene.Net.Documents
      */
 
     /// <summary>
-    /// A <seealso cref="StoredFieldVisitor"/> that creates a {@link
-    ///  Document} containing all stored fields, or only specific
-    ///  requested fields provided to <seealso cref="#DocumentStoredFieldVisitor(Set)"/>.
-    ///  <p>
-    ///  this is used by <seealso cref="IndexReader#document(int)"/> to load a
-    ///  document.
+    /// A <see cref="StoredFieldVisitor"/> that creates a 
+    /// <see cref="Document"/> containing all stored fields, or only specific
+    /// requested fields provided to <see cref="DocumentStoredFieldVisitor.DocumentStoredFieldVisitor(ISet{string})"/>.
+    /// <para/>
+    /// This is used by <see cref="IndexReader.Document(int)"/> to load a
+    /// document.
     ///
     /// @lucene.experimental
     /// </summary>
-
     public class DocumentStoredFieldVisitor : StoredFieldVisitor
     {
         private readonly Documents.Document doc = new Documents.Document();
         private readonly ISet<string> fieldsToAdd;
 
         /// <summary>
-        /// Load only fields named in the provided <code>Set&lt;String&gt;</code>. </summary>
-        /// <param name="fieldsToAdd"> Set of fields to load, or <code>null</code> (all fields). </param>
+        /// Load only fields named in the provided <see cref="ISet{String}"/>. </summary>
+        /// <param name="fieldsToAdd"> Set of fields to load, or <c>null</c> (all fields). </param>
         public DocumentStoredFieldVisitor(ISet<string> fieldsToAdd)
         {
             this.fieldsToAdd = fieldsToAdd;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/117429e8/src/Lucene.Net.Core/Document/DoubleDocValuesField.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Document/DoubleDocValuesField.cs b/src/Lucene.Net.Core/Document/DoubleDocValuesField.cs
index 083dbf8..53f8abb 100644
--- a/src/Lucene.Net.Core/Document/DoubleDocValuesField.cs
+++ b/src/Lucene.Net.Core/Document/DoubleDocValuesField.cs
@@ -19,16 +19,13 @@ namespace Lucene.Net.Documents
      * limitations under the License.
      */
 
-    // javadocs
-    // javadocs
-
     /// <summary>
-    /// Syntactic sugar for encoding doubles as NumericDocValues
-    /// via <seealso cref="Double#doubleToRawLongBits(double)"/>.
-    /// 
+    /// Syntactic sugar for encoding doubles as <see cref="Index.NumericDocValues"/>
+    /// via <see cref="Support.Number.DoubleToRawInt64Bits(double)"/>.
+    /// <para/>
     /// Per-document double values can be retrieved via
-    /// <seealso cref="IFieldCache#getDoubles(AtomicReader, String, boolean)"/>.
-    /// 
+    /// <see cref="Search.IFieldCache.GetDoubles(Lucene.Net.Index.AtomicReader, string, bool)"/>.
+    /// <para/>
     /// <b>NOTE</b>: In most all cases this will be rather inefficient,
     /// requiring eight bytes per document. Consider encoding double
     /// values yourself with only as much precision as you require.
@@ -36,10 +33,10 @@ namespace Lucene.Net.Documents
     public class DoubleDocValuesField : NumericDocValuesField
     {
         /// <summary>
-        /// Creates a new DocValues field with the specified 64-bit double value </summary>
+        /// Creates a new <see cref="Index.DocValues"/> field with the specified 64-bit double value </summary>
         /// <param name="name"> field name </param>
         /// <param name="value"> 64-bit double value </param>
-        /// <exception cref="ArgumentException"> if the field name is null </exception>
+        /// <exception cref="ArgumentNullException"> if the field name is <c>null</c> </exception>
         public DoubleDocValuesField(string name, double value)
             : base(name, BitConverter.DoubleToInt64Bits(value))
         {
@@ -52,7 +49,7 @@ namespace Lucene.Net.Documents
 
         public override void SetInt64Value(long value)
         {
-            throw new System.ArgumentException("cannot change value type from Double to Long");
+            throw new System.ArgumentException("cannot change value type from System.Double to System.Int64");
         }
     }
 }
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/117429e8/src/Lucene.Net.Core/Document/DoubleField.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Document/DoubleField.cs b/src/Lucene.Net.Core/Document/DoubleField.cs
index d53c652..5aaf2aa 100644
--- a/src/Lucene.Net.Core/Document/DoubleField.cs
+++ b/src/Lucene.Net.Core/Document/DoubleField.cs
@@ -21,102 +21,103 @@ namespace Lucene.Net.Documents
      */
 
     /// <summary>
-    /// <p>
-    /// Field that indexes <code>double</code> values
+    /// <para>
+    /// Field that indexes <see cref="double"/> values
     /// for efficient range filtering and sorting. Here's an example usage:
     ///
-    /// <pre class="prettyprint">
-    /// document.add(new DoubleField(name, 6.0, Field.Store.NO));
-    /// </pre>
+    /// <code>
+    /// document.Add(new DoubleField(name, 6.0, Field.Store.NO));
+    /// </code>
     ///
-    /// For optimal performance, re-use the <code>DoubleField</code> and
-    /// <seealso cref="Document"/> instance for more than one document:
+    /// For optimal performance, re-use the <see cref="DoubleField"/> and
+    /// <see cref="Document"/> instance for more than one document:
     ///
-    /// <pre class="prettyprint">
-    ///  DoubleField field = new DoubleField(name, 0.0, Field.Store.NO);
-    ///  Document document = new Document();
-    ///  document.add(field);
+    /// <code>
+    ///     DoubleField field = new DoubleField(name, 0.0, Field.Store.NO);
+    ///     Document document = new Document();
+    ///     document.Add(field);
     ///
-    ///  for(all documents) {
-    ///    ...
-    ///    field.setDoubleValue(value)
-    ///    writer.addDocument(document);
-    ///    ...
-    ///  }
-    /// </pre>
+    ///     for (all documents)
+    ///     {
+    ///         ...
+    ///         field.SetDoubleValue(value)
+    ///         writer.AddDocument(document);
+    ///         ...
+    ///     }
+    /// </code>
     ///
-    /// See also <seealso cref="Int32Field"/>, <seealso cref="Int64Field"/>, {@link
-    /// FloatField}.</p>
+    /// See also <seealso cref="Int32Field"/>, <seealso cref="Int64Field"/>, 
+    /// <see cref="SingleField"/>.</para>
     ///
-    /// <p>To perform range querying or filtering against a
-    /// <code>DoubleField</code>, use <seealso cref="NumericRangeQuery"/> or {@link
-    /// NumericRangeFilter}.  To sort according to a
-    /// <code>DoubleField</code>, use the normal numeric sort types, eg
-    /// <seealso cref="Lucene.Net.Search.SortField.Type#DOUBLE"/>. <code>DoubleField</code>
-    /// values can also be loaded directly from <seealso cref="IFieldCache"/>.</p>
+    /// <para>To perform range querying or filtering against a
+    /// <see cref="DoubleField"/>, use <see cref="Search.NumericRangeQuery"/> or 
+    /// <see cref="Search.NumericRangeFilter{T}"/>.  To sort according to a
+    /// <see cref="DoubleField"/>, use the normal numeric sort types, eg
+    /// <see cref="Lucene.Net.Search.SortFieldType.DOUBLE"/>. <see cref="DoubleField"/>
+    /// values can also be loaded directly from <see cref="Search.IFieldCache"/>.</para>
     ///
-    /// <p>You may add the same field name as an <code>DoubleField</code> to
+    /// <para>You may add the same field name as an <see cref="DoubleField"/> to
     /// the same document more than once.  Range querying and
     /// filtering will be the logical OR of all values; so a range query
     /// will hit all documents that have at least one value in
     /// the range. However sort behavior is not defined.  If you need to sort,
-    /// you should separately index a single-valued <code>DoubleField</code>.</p>
+    /// you should separately index a single-valued <see cref="DoubleField"/>.</para>
     ///
-    /// <p>A <code>DoubleField</code> will consume somewhat more disk space
+    /// <para>A <see cref="DoubleField"/> will consume somewhat more disk space
     /// in the index than an ordinary single-valued field.
     /// However, for a typical index that includes substantial
     /// textual content per document, this increase will likely
-    /// be in the noise. </p>
+    /// be in the noise. </para>
     ///
-    /// <p>Within Lucene, each numeric value is indexed as a
+    /// <para>Within Lucene, each numeric value is indexed as a
     /// <em>trie</em> structure, where each term is logically
     /// assigned to larger and larger pre-defined brackets (which
     /// are simply lower-precision representations of the value).
     /// The step size between each successive bracket is called the
-    /// <code>precisionStep</code>, measured in bits.  Smaller
-    /// <code>precisionStep</code> values result in larger number
+    /// <c>precisionStep</c>, measured in bits.  Smaller
+    /// <c>precisionStep</c> values result in larger number
     /// of brackets, which consumes more disk space in the index
     /// but may result in faster range search performance.  The
     /// default value, 4, was selected for a reasonable tradeoff
     /// of disk space consumption versus performance.  You can
-    /// create a custom <seealso cref="FieldType"/> and invoke the {@link
-    /// FieldType#setNumericPrecisionStep} method if you'd
+    /// create a custom <see cref="FieldType"/> and invoke the
+    /// <see cref="FieldType.NumericPrecisionStep"/> setter if you'd
     /// like to change the value.  Note that you must also
-    /// specify a congruent value when creating {@link
-    /// NumericRangeQuery} or <seealso cref="NumericRangeFilter"/>.
+    /// specify a congruent value when creating 
+    /// <see cref="Search.NumericRangeQuery{T}"/> or <see cref="Search.NumericRangeFilter{T}"/>.
     /// For low cardinality fields larger precision steps are good.
     /// If the cardinality is &lt; 100, it is fair
-    /// to use <seealso cref="Integer#MAX_VALUE"/>, which produces one
-    /// term per value.</p>
+    /// to use <see cref="int.MaxValue"/>, which produces one
+    /// term per value.</para>
     ///
-    /// <p>For more information on the internals of numeric trie
-    /// indexing, including the <a
-    /// href="../search/NumericRangeQuery.html#precisionStepDesc"><code>precisionStep</code></a>
-    /// configuration, see <seealso cref="NumericRangeQuery"/>. The format of
-    /// indexed values is described in <seealso cref="NumericUtils"/>.</p>
+    /// <para>For more information on the internals of numeric trie
+    /// indexing, including the <see cref="Search.NumericRangeQuery{T}.PrecisionStep"/> (<a
+    /// href="../search/NumericRangeQuery.html#precisionStepDesc"><c>precisionStep</c></a>)
+    /// configuration, see <see cref="Search.NumericRangeQuery{T}"/>. The format of
+    /// indexed values is described in <see cref="Util.NumericUtils"/>.</para>
     ///
-    /// <p>If you only need to sort by numeric value, and never
+    /// <para>If you only need to sort by numeric value, and never
     /// run range querying/filtering, you can index using a
-    /// <code>precisionStep</code> of <seealso cref="Integer#MAX_VALUE"/>.
-    /// this will minimize disk space consumed. </p>
+    /// <c>precisionStep</c> of <see cref="int.MaxValue"/>.
+    /// this will minimize disk space consumed. </para>
     ///
-    /// <p>More advanced users can instead use {@link
-    /// NumericTokenStream} directly, when indexing numbers. this
+    /// <para>More advanced users can instead use 
+    /// <see cref="Analysis.NumericTokenStream"/> directly, when indexing numbers. This
     /// class is a wrapper around this token stream type for
-    /// easier, more intuitive usage.</p>
+    /// easier, more intuitive usage.</para>
     ///
     /// @since 2.9
     /// </summary>
     public sealed class DoubleField : Field
     {
         /// <summary>
-        /// Type for a DoubleField that is not stored:
+        /// Type for a <see cref="DoubleField"/> that is not stored:
         /// normalization factors, frequencies, and positions are omitted.
         /// </summary>
         public static readonly FieldType TYPE_NOT_STORED = new FieldType();
 
         /// <summary>
-        /// Type for a stored DoubleField:
+        /// Type for a stored <see cref="DoubleField"/>:
         /// normalization factors, frequencies, and positions are omitted.
         /// </summary>
         public static readonly FieldType TYPE_STORED = new FieldType();
@@ -140,13 +141,14 @@ namespace Lucene.Net.Documents
         }
 
         /// <summary>
-        /// Creates a stored or un-stored DoubleField with the provided value
-        ///  and default <code>precisionStep</code> {@link
-        ///  NumericUtils#PRECISION_STEP_DEFAULT} (4). </summary>
-        ///  <param name="name"> field name </param>
-        ///  <param name="value"> 64-bit double value </param>
-        ///  <param name="stored"> Store.YES if the content should also be stored </param>
-        ///  <exception cref="IllegalArgumentException"> if the field name is null.  </exception>
+        /// Creates a stored or un-stored <see cref="DoubleField"/> with the provided value
+        /// and default <c>precisionStep</c> 
+        /// <see cref="Util.NumericUtils.PRECISION_STEP_DEFAULT"/> (4).
+        /// </summary>
+        /// <param name="name"> field name </param>
+        /// <param name="value"> 64-bit <see cref="double"/> value </param>
+        /// <param name="stored"> <see cref="Field.Store.YES"/> if the content should also be stored </param>
+        /// <exception cref="ArgumentNullException"> if the field name is <c>null</c>.  </exception>
         public DoubleField(string name, double value, Store stored)
             : base(name, stored == Store.YES ? TYPE_STORED : TYPE_NOT_STORED)
         {
@@ -154,14 +156,14 @@ namespace Lucene.Net.Documents
         }
 
         /// <summary>
-        /// Expert: allows you to customize the {@link
-        ///  FieldType}. </summary>
-        ///  <param name="name"> field name </param>
-        ///  <param name="value"> 64-bit double value </param>
-        ///  <param name="type"> customized field type: must have <seealso cref="FieldType#numericType()"/>
-        ///         of <seealso cref="NumericType#DOUBLE"/>. </param>
-        ///  <exception cref="IllegalArgumentException"> if the field name or type is null, or
-        ///          if the field type does not have a DOUBLE numericType() </exception>
+        /// Expert: allows you to customize the <see cref="FieldType"/>. 
+        /// </summary>
+        /// <param name="name"> field name </param>
+        /// <param name="value"> 64-bit double value </param>
+        /// <param name="type"> customized field type: must have <see cref="FieldType.NumericType"/>
+        ///         of <see cref="NumericType.DOUBLE"/>. </param>
+        /// <exception cref="ArgumentNullException"> if the field name or type is <c>null</c>, or
+        ///          if the field type does not have a DOUBLE <see cref="FieldType.NumericType"/> </exception>
         public DoubleField(string name, double value, FieldType type)
             : base(name, type)
         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/117429e8/src/Lucene.Net.Core/Document/Field.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Document/Field.cs b/src/Lucene.Net.Core/Document/Field.cs
index 7f8e599..72a778c 100644
--- a/src/Lucene.Net.Core/Document/Field.cs
+++ b/src/Lucene.Net.Core/Document/Field.cs
@@ -27,23 +27,24 @@ namespace Lucene.Net.Documents
 
     /// <summary>
     /// Expert: directly create a field for a document.  Most
-    /// users should use one of the sugar subclasses: {@link
-    /// IntField}, <seealso cref="Int64Field"/>, <seealso cref="SingleField"/>, {@link
-    /// DoubleField}, <seealso cref="BinaryDocValuesField"/>, {@link
-    /// NumericDocValuesField}, <seealso cref="SortedDocValuesField"/>, {@link
-    /// StringField}, <seealso cref="TextField"/>, <seealso cref="StoredField"/>.
+    /// users should use one of the sugar subclasses: <see cref="Int32Field"/>, 
+    /// <see cref="Int64Field"/>, <see cref="SingleField"/>, <see cref="DoubleField"/>, 
+    /// <see cref="BinaryDocValuesField"/>, <see cref="NumericDocValuesField"/>,
+    /// <see cref="SortedDocValuesField"/>, <see cref="StringField"/>,
+    /// <see cref="TextField"/>, <see cref="StoredField"/>.
     ///
-    /// <p/> A field is a section of a Document. Each field has three
+    /// <para/> A field is a section of a <see cref="Document"/>. Each field has three
     /// parts: name, type and value. Values may be text
-    /// (String, TextReader or pre-analyzed TokenStream), binary
-    /// (byte[]), or numeric (a Number).  Fields are optionally stored in the
+    /// (<see cref="string"/>, <see cref="TextReader"/> or pre-analyzed <see cref="TokenStream"/>), binary
+    /// (<see cref="T:byte[]"/>), or numeric (<see cref="int"/>, <see cref="long"/>, <see cref="float"/>, or <see cref="double"/>). 
+    /// Fields are optionally stored in the
     /// index, so that they may be returned with hits on the document.
     ///
-    /// <p/>
-    /// NOTE: the field type is an <seealso cref="IIndexableFieldType"/>.  Making changes
-    /// to the state of the IndexableFieldType will impact any
+    /// <para/>
+    /// NOTE: the field type is an <see cref="IIndexableFieldType"/>.  Making changes
+    /// to the state of the <see cref="IIndexableFieldType"/> will impact any
     /// Field it is used in.  It is strongly recommended that no
-    /// changes be made after Field instantiation.
+    /// changes be made after <see cref="Field"/> instantiation.
     /// </summary>
     public class Field : IIndexableField
     {
@@ -62,9 +63,9 @@ namespace Lucene.Net.Documents
         protected object m_fieldsData;
 
         /// <summary>
-        /// Pre-analyzed tokenStream for indexed fields; this is
-        /// separate from fieldsData because you are allowed to
-        /// have both; eg maybe field has a String value but you
+        /// Pre-analyzed <see cref="TokenStream"/> for indexed fields; this is
+        /// separate from <see cref="m_fieldsData"/> because you are allowed to
+        /// have both; eg maybe field has a <see cref="string"/> value but you
         /// customize how it's tokenized
         /// </summary>
         protected TokenStream m_tokenStream;
@@ -73,16 +74,17 @@ namespace Lucene.Net.Documents
 
         /// <summary>
         /// Field's boost </summary>
-        /// <seealso cref= #boost() </seealso>
+        /// <seealso cref="Boost"/>
         protected float m_boost = 1.0f;
 
         /// <summary>
         /// Expert: creates a field with no initial value.
-        /// Intended only for custom Field subclasses. </summary>
+        /// Intended only for custom <see cref="Field"/> subclasses.
+        /// </summary>
         /// <param name="name"> field name </param>
         /// <param name="type"> field type </param>
-        /// <exception cref="ArgumentNullException"> if either the name or type
-        ///         is null. </exception>
+        /// <exception cref="ArgumentNullException"> if either the <paramref name="name"/> or <paramref name="type"/>
+        ///         is <c>null</c>. </exception>
         protected internal Field(string name, FieldType type)
         {
             if (name == null)
@@ -98,14 +100,14 @@ namespace Lucene.Net.Documents
         }
 
         /// <summary>
-        /// Create field with TextReader value. </summary>
+        /// Create field with <see cref="TextReader"/> value. </summary>
         /// <param name="name"> field name </param>
         /// <param name="reader"> reader value </param>
         /// <param name="type"> field type </param>
-        /// <exception cref="ArgumentNullException"> if either the name or type
-        ///         is null, or if the field's type is stored(), or
-        ///         if tokenized() is false. </exception>
-        /// <exception cref="ArgumentNullException"> if the reader is null </exception>
+        /// <exception cref="ArgumentException"> if <see cref="FieldType.IsStored"/> is true, or
+        ///         if <see cref="FieldType.IsTokenized"/> is false. </exception>
+        /// <exception cref="ArgumentNullException"> if either the <paramref name="name"/> or <paramref name="type"/>
+        ///         is <c>null</c>, or if the reader is <c>null</c> </exception>
         public Field(string name, TextReader reader, FieldType type)
         {
             if (name == null)
@@ -135,14 +137,14 @@ namespace Lucene.Net.Documents
         }
 
         /// <summary>
-        /// Create field with TokenStream value. </summary>
+        /// Create field with <see cref="TokenStream"/> value. </summary>
         /// <param name="name"> field name </param>
         /// <param name="tokenStream"> TokenStream value </param>
         /// <param name="type"> field type </param>
-        /// <exception cref="ArgumentException"> if either the name or type
-        ///         is null, or if the field's type is stored(), or
-        ///         if tokenized() is false, or if indexed() is false. </exception>
-        /// <exception cref="ArgumentNullException"> if the tokenStream is null </exception>
+        /// <exception cref="ArgumentException"> if <see cref="FieldType.IsStored"/> is true, or
+        ///         if <see cref="FieldType.IsTokenized"/> is false, or if <see cref="FieldType.IsIndexed"/> is false. </exception>
+        /// <exception cref="ArgumentNullException"> if either the <paramref name="name"/> or <paramref name="type"/>
+        ///         is <c>null</c>, or if the <paramref name="tokenStream"/> is <c>null</c> </exception>
         public Field(string name, TokenStream tokenStream, FieldType type)
         {
             if (name == null)
@@ -151,7 +153,7 @@ namespace Lucene.Net.Documents
             }
             if (tokenStream == null)
             {
-                throw new System.ArgumentNullException("tokenStream","tokenStream cannot be null");
+                throw new System.ArgumentNullException("tokenStream", "tokenStream cannot be null");
             }
             if (type == null)
             {
@@ -175,14 +177,15 @@ namespace Lucene.Net.Documents
         /// <summary>
         /// Create field with binary value.
         ///
-        /// <p>NOTE: the provided byte[] is not copied so be sure
-        /// not to change it until you're done with this field. </summary>
+        /// <para/>NOTE: the provided <see cref="T:byte[]"/> is not copied so be sure
+        /// not to change it until you're done with this field.
+        /// </summary>
         /// <param name="name"> field name </param>
         /// <param name="value"> byte array pointing to binary content (not copied) </param>
         /// <param name="type"> field type </param>
-        /// <exception cref="ArgumentException"> if the field name is null,
-        ///         or the field's type is indexed() </exception>
-        /// <exception cref="ArgumentNullException"> if the type is null </exception>
+        /// <exception cref="ArgumentException"> if the <see cref="FieldType.IsIndexed"/> is true </exception>
+        /// <exception cref="ArgumentNullException"> the field <paramref name="name"/> is <c>null</c>,
+        ///         or if the <paramref name="type"/> is <c>null</c> </exception>
         public Field(string name, byte[] value, FieldType type)
             : this(name, value, 0, value.Length, type)
         {
@@ -191,16 +194,17 @@ namespace Lucene.Net.Documents
         /// <summary>
         /// Create field with binary value.
         ///
-        /// <p>NOTE: the provided byte[] is not copied so be sure
-        /// not to change it until you're done with this field. </summary>
+        /// <para/>NOTE: the provided <see cref="T:byte[]"/> is not copied so be sure
+        /// not to change it until you're done with this field.
+        /// </summary>
         /// <param name="name"> field name </param>
         /// <param name="value"> byte array pointing to binary content (not copied) </param>
         /// <param name="offset"> starting position of the byte array </param>
         /// <param name="length"> valid length of the byte array </param>
         /// <param name="type"> field type </param>
-        /// <exception cref="ArgumentException"> if the field name is null,
-        ///         or the field's type is indexed() </exception>
-        /// <exception cref="ArgumentNullException"> if the type is null </exception>
+        /// <exception cref="ArgumentException"> if the <see cref="FieldType.IsIndexed"/> is true </exception>
+        /// <exception cref="ArgumentNullException"> if the field <paramref name="name"/> is <c>null</c>,
+        ///         or the <paramref name="type"/> is <c>null</c> </exception>
         public Field(string name, byte[] value, int offset, int length, FieldType type)
             : this(name, new BytesRef(value, offset, length), type)
         {
@@ -209,14 +213,15 @@ namespace Lucene.Net.Documents
         /// <summary>
         /// Create field with binary value.
         ///
-        /// <p>NOTE: the provided BytesRef is not copied so be sure
-        /// not to change it until you're done with this field. </summary>
+        /// <para/>NOTE: the provided BytesRef is not copied so be sure
+        /// not to change it until you're done with this field.
+        /// </summary>
         /// <param name="name"> field name </param>
         /// <param name="bytes"> BytesRef pointing to binary content (not copied) </param>
         /// <param name="type"> field type </param>
-        /// <exception cref="ArgumentException"> if the field name is null,
-        ///         or the field's type is indexed() </exception>
-        /// <exception cref="ArgumentNullException"> if the type is null </exception>
+        /// <exception cref="ArgumentException"> if the <see cref="FieldType.IsIndexed"/> is true </exception>
+        /// <exception cref="ArgumentNullException"> if the field <paramref name="name"/> is <c>null</c>,
+        ///         or the <paramref name="type"/> is <c>null</c> </exception>
         public Field(string name, BytesRef bytes, FieldType type)
         {
             if (name == null)
@@ -239,14 +244,14 @@ namespace Lucene.Net.Documents
         // TODO: allow direct construction of int, long, float, double value too..?
 
         /// <summary>
-        /// Create field with String value. </summary>
+        /// Create field with <see cref="string"/> value. </summary>
         /// <param name="name"> field name </param>
         /// <param name="value"> string value </param>
         /// <param name="type"> field type </param>
-        /// <exception cref="ArgumentException"> if either the name or value
-        ///         is null, or if the field's type is neither indexed() nor stored(),
+        /// <exception cref="ArgumentException"> if the field's type is neither indexed() nor stored(),
         ///         or if indexed() is false but storeTermVectors() is true. </exception>
-        /// <exception cref="ArgumentNullException"> if the type is null </exception>
+        /// <exception cref="ArgumentNullException"> if either the <paramref name="name"/> or <paramref name="value"/>
+        ///         is <c>null</c>, or if the <paramref name="type"/> is <c>null</c> </exception>
         public Field(string name, string value, FieldType type)
         {
             if (name == null)
@@ -276,7 +281,7 @@ namespace Lucene.Net.Documents
         }
 
         /// <summary>
-        /// The value of the field as a string, or null. If null, the <see cref="TextReader"/> value or
+        /// The value of the field as a <see cref="string"/>, or <c>null</c>. If <c>null</c>, the <see cref="TextReader"/> value or
         /// binary value is used. Exactly one of <see cref="GetStringValue()"/>, <see cref="GetReaderValue()"/>, and
         /// <see cref="GetBinaryValue()"/> must be set.
         /// </summary>
@@ -293,7 +298,7 @@ namespace Lucene.Net.Documents
         }
 
         /// <summary>
-        /// The value of the field as a <see cref="TextReader"/>, or null. If null, the string value or
+        /// The value of the field as a <see cref="TextReader"/>, or <c>null</c>. If <c>null</c>, the <see cref="string"/> value or
         /// binary value is used. Exactly one of <see cref="GetStringValue()"/>, <see cref="GetReaderValue()"/>, and
         /// <see cref="GetBinaryValue()"/> must be set.
         /// </summary>
@@ -303,8 +308,8 @@ namespace Lucene.Net.Documents
         }
 
         /// <summary>
-        /// The TokenStream for this field to be used when indexing, or null. If null,
-        /// the TextReader value or String value is analyzed to produce the indexed tokens.
+        /// The <see cref="TokenStream"/> for this field to be used when indexing, or <c>null</c>. If <c>null</c>,
+        /// the <see cref="TextReader"/> value or <see cref="string"/> value is analyzed to produce the indexed tokens.
         /// </summary>
         public virtual TokenStream GetTokenStreamValue() // LUCENENET specific: Added verb Get to make it more clear that this returns the value
         {
@@ -312,20 +317,20 @@ namespace Lucene.Net.Documents
         }
 
         /// <summary>
-        /// <p>
-        /// Expert: change the value of this field. this can be used during indexing to
-        /// re-use a single Field instance to improve indexing speed by avoiding GC
-        /// cost of new'ing and reclaiming Field instances. Typically a single
-        /// <seealso cref="Document"/> instance is re-used as well. this helps most on small
+        /// <para>
+        /// Expert: change the value of this field. This can be used during indexing to
+        /// re-use a single <see cref="Field"/> instance to improve indexing speed by avoiding GC
+        /// cost of new'ing and reclaiming <see cref="Field"/> instances. Typically a single
+        /// <see cref="Document"/> instance is re-used as well. This helps most on small
         /// documents.
-        /// </p>
+        /// </para>
         ///
-        /// <p>
-        /// Each Field instance should only be used once within a single
-        /// <seealso cref="Document"/> instance. See <a
+        /// <para>
+        /// Each <see cref="Field"/> instance should only be used once within a single
+        /// <see cref="Document"/> instance. See <a
         /// href="http://wiki.apache.org/lucene-java/ImproveIndexingSpeed"
         /// >ImproveIndexingSpeed</a> for details.
-        /// </p>
+        /// </para>
         /// </summary>
         public virtual void SetStringValue(string value)
         {
@@ -353,7 +358,7 @@ namespace Lucene.Net.Documents
         /// Expert: change the value of this field. See
         /// <see cref="SetStringValue(string)"/>.
         ///
-        /// <p>NOTE: the provided BytesRef is not copied so be sure
+        /// <para/>NOTE: the provided <see cref="BytesRef"/> is not copied so be sure
         /// not to change it until you're done with this field.
         /// </summary>
         public virtual void SetBytesValue(BytesRef value)
@@ -462,8 +467,8 @@ namespace Lucene.Net.Documents
 
         /// <summary>
         /// Expert: sets the token stream to be used for indexing and causes
-        /// isIndexed() and isTokenized() to return true. May be combined with stored
-        /// values from stringValue() or getBinaryValue()
+        /// <see cref="FieldType.IsIndexed"/> and <see cref="FieldType.IsTokenized"/> to return true. May be combined with stored
+        /// values from <see cref="GetStringValue()"/> or <see cref="GetBinaryValue()"/>
         /// </summary>
         public virtual void SetTokenStream(TokenStream tokenStream)
         {
@@ -478,15 +483,19 @@ namespace Lucene.Net.Documents
             this.m_tokenStream = tokenStream;
         }
 
+        /// <summary>
+        /// The field's name
+        /// </summary>
         public virtual string Name
         {
             get { return m_name; }
         }
 
         /// <summary>
-        /// Gets or sets the boost factor on this field. </summary>
+        /// Gets or sets the boost factor on this field.
+        /// </summary>
         /// <remarks>The default value is <c>1.0f</c> (no boost).</remarks>
-        /// <exception cref="ArgumentException"> if this field is not indexed,
+        /// <exception cref="ArgumentException"> (setter only) if this field is not indexed,
         ///         or if it omits norms. </exception>
         public virtual float Boost
         {
@@ -536,7 +545,7 @@ namespace Lucene.Net.Documents
         }
 
         /// <summary>
-        /// Prints a Field for human consumption. </summary>
+        /// Prints a <see cref="Field"/> for human consumption. </summary>
         public override string ToString()
         {
             StringBuilder result = new StringBuilder();
@@ -555,7 +564,7 @@ namespace Lucene.Net.Documents
         }
 
         /// <summary>
-        /// Returns the <seealso cref="FieldType"/> for this field. </summary>
+        /// Returns the <see cref="Documents.FieldType"/> for this field. </summary>
         public virtual IIndexableFieldType FieldType
         {
             get { return m_type; }
@@ -650,9 +659,9 @@ namespace Lucene.Net.Documents
             internal string value = null;
 
             /// <summary>
-            /// Creates a new TokenStream that returns a String as single token.
-            /// <p>Warning: Does not initialize the value, you must call
-            /// <seealso cref="#setValue(String)"/> afterwards!
+            /// Creates a new <see cref="TokenStream"/> that returns a <see cref="string"/> as single token.
+            /// <para/>Warning: Does not initialize the value, you must call
+            /// <see cref="SetValue(string)"/> afterwards!
             /// </summary>
             internal StringTokenStream()
             {
@@ -720,8 +729,8 @@ namespace Lucene.Net.Documents
         //
 
         /// <summary>
-        /// Specifies whether and how a field should be indexed.
-        /// <summary>Specifies whether and how a field should be indexed. </summary>
+        /// Specifies whether and how a field should be indexed. 
+        /// </summary>
         [Obsolete("This is here only to ease transition from the pre-4.0 APIs.")]
         public enum Index
         {
@@ -732,12 +741,12 @@ namespace Lucene.Net.Documents
             NO,
 
             /// <summary>Index the tokens produced by running the field's
-            /// value through an Analyzer.  This is useful for
+            /// value through an <see cref="Analyzer"/>.  This is useful for
             /// common text.
             /// </summary>
             ANALYZED,
 
-            /// <summary>Index the field's value without using an Analyzer, so it can be searched.
+            /// <summary>Index the field's value without using an <see cref="Analyzer"/>, so it can be searched.
             /// As no analyzer is used the value will be stored as a single term. This is
             /// useful for unique Ids like product numbers.
             /// </summary>
@@ -746,7 +755,7 @@ namespace Lucene.Net.Documents
             /// <summary>Expert: Index the field's value without an Analyzer,
             /// and also disable the storing of norms.  Note that you
             /// can also separately enable/disable norms by setting
-            /// <see cref="AbstractField.OmitNorms" />.  No norms means that
+            /// <see cref="FieldType.OmitNorms" />.  No norms means that
             /// index-time field and document boosting and field
             /// length normalization are disabled.  The benefit is
             /// less memory usage as norms take up one byte of RAM
@@ -770,48 +779,46 @@ namespace Lucene.Net.Documents
         }
 
         /// <summary>
-        /// Specifies whether and how a field should have term vectors.
+        /// Specifies whether and how a field should have term vectors. 
         /// </summary>
         [Obsolete("This is here only to ease transition from the pre-4.0 APIs.")]
         public enum TermVector
         {
-            /// <summary>Do not store term vectors. </summary>
+            /// <summary>
+            /// Do not store term vectors. 
+            /// </summary>
             NO,
 
-            /// <summary>Store the term vectors of each document. A term vector is a list
+            /// <summary>
+            /// Store the term vectors of each document. A term vector is a list
             /// of the document's terms and their number of occurrences in that document.
             /// </summary>
             YES,
 
-            /// <summary> Store the term vector + token position information
-            ///
+            /// <summary>
+            /// Store the term vector + token position information
             /// </summary>
-            /// <seealso cref="YES">
-            /// </seealso>
+            /// <seealso cref="YES"/>
             WITH_POSITIONS,
 
-            /// <summary> Store the term vector + Token offset information
-            ///
+            /// <summary>
+            /// Store the term vector + Token offset information
             /// </summary>
-            /// <seealso cref="YES">
-            /// </seealso>
+            /// <seealso cref="YES"/>
             WITH_OFFSETS,
 
-            /// <summary> Store the term vector + Token position and offset information
-            ///
+            /// <summary>
+            /// Store the term vector + Token position and offset information
             /// </summary>
-            /// <seealso cref="YES">
-            /// </seealso>
-            /// <seealso cref="WITH_POSITIONS">
-            /// </seealso>
-            /// <seealso cref="WITH_OFFSETS">
-            /// </seealso>
+            /// <seealso cref="YES"/>
+            /// <seealso cref="WITH_POSITIONS"/>
+            /// <seealso cref="WITH_OFFSETS"/>
             WITH_POSITIONS_OFFSETS,
         }
 
         /// <summary>
         /// Translates the pre-4.0 enums for specifying how a
-        /// field should be indexed into the 4.0 {@link FieldType}
+        /// field should be indexed into the 4.0 <see cref="Documents.FieldType"/>
         /// approach.
         /// </summary>
         [Obsolete("This is here only to ease transition from the pre-4.0 APIs.")]
@@ -879,7 +886,7 @@ namespace Lucene.Net.Documents
         }
 
         /// <summary>
-        /// Create a field by specifying its name, value and how it will
+        /// Create a field by specifying its <paramref name="name"/>, <paramref name="value"/> and how it will
         /// be saved in the index. Term vectors will not be stored in the index.
         /// </summary>
         /// <param name="name">The name of the field</param>
@@ -896,7 +903,7 @@ namespace Lucene.Net.Documents
         }
 
         /// <summary>
-        /// Create a field by specifying its name, value and how it will
+        /// Create a field by specifying its <paramref name="name"/>, <paramref name="value"/> and how it will
         /// be saved in the index.
         /// </summary>
         /// <param name="name">The name of the field</param>
@@ -1007,6 +1014,10 @@ namespace Lucene.Net.Documents
         }
     }
 
+    /// <summary>
+    /// LUCENENET specific extension methods to add functionality to enumerations
+    /// that mimic Lucene
+    /// </summary>
     public static class FieldExtensions
     {
         public static bool IsStored(this Field.Store store)


Mime
View raw message