lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From nightowl...@apache.org
Subject [7/9] lucenenet git commit: SWEEP: Lucene.Net.Index: Fixed up documentation comments for types starting with M-Z
Date Thu, 01 Jun 2017 22:49:03 GMT
SWEEP: Lucene.Net.Index: Fixed up documentation comments for types starting with M-Z


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

Branch: refs/heads/master
Commit: 646db0ce2d64e564e9bc8da3420d62e34e2bacb2
Parents: 7099a84
Author: Shad Storhaug <shad@shadstorhaug.com>
Authored: Fri Jun 2 04:26:52 2017 +0700
Committer: Shad Storhaug <shad@shadstorhaug.com>
Committed: Fri Jun 2 04:26:52 2017 +0700

----------------------------------------------------------------------
 CONTRIBUTING.md                                 |   7 +-
 src/Lucene.Net/Index/MergePolicy.cs             | 199 +++++++-------
 src/Lucene.Net/Index/MergeScheduler.cs          |  20 +-
 src/Lucene.Net/Index/MergeState.cs              |  33 +--
 src/Lucene.Net/Index/MergeTrigger.cs            |   6 +-
 src/Lucene.Net/Index/MultiBits.cs               |  18 +-
 src/Lucene.Net/Index/MultiDocValues.cs          |  97 +++----
 .../Index/MultiDocsAndPositionsEnum.cs          |  20 +-
 src/Lucene.Net/Index/MultiDocsEnum.cs           |  22 +-
 src/Lucene.Net/Index/MultiFields.cs             | 117 ++++----
 src/Lucene.Net/Index/MultiReader.cs             |  24 +-
 src/Lucene.Net/Index/MultiTerms.cs              |   8 +-
 src/Lucene.Net/Index/MultiTermsEnum.cs          |  19 +-
 src/Lucene.Net/Index/NoDeletionPolicy.cs        |   6 +-
 src/Lucene.Net/Index/NoMergePolicy.cs           |  12 +-
 src/Lucene.Net/Index/NoMergeScheduler.cs        |  10 +-
 src/Lucene.Net/Index/NormsConsumer.cs           |   4 +-
 .../Index/NumericDocValuesFieldUpdates.cs       |   6 +-
 src/Lucene.Net/Index/NumericDocValuesWriter.cs  |  90 +-----
 src/Lucene.Net/Index/OrdTermState.cs            |   6 +-
 src/Lucene.Net/Index/ParallelAtomicReader.cs    |  27 +-
 src/Lucene.Net/Index/ParallelCompositeReader.cs |  28 +-
 .../Index/PersistentSnapshotDeletionPolicy.cs   |  60 ++--
 src/Lucene.Net/Index/PrefixCodedTerms.cs        |   7 +-
 src/Lucene.Net/Index/RandomAccessOrds.cs        |  18 +-
 src/Lucene.Net/Index/ReaderManager.cs           |  38 +--
 src/Lucene.Net/Index/ReaderSlice.cs             |   4 +-
 src/Lucene.Net/Index/ReaderUtil.cs              |   8 +-
 src/Lucene.Net/Index/ReadersAndUpdates.cs       | 186 +------------
 src/Lucene.Net/Index/SegmentCommitInfo.cs       |  34 +--
 src/Lucene.Net/Index/SegmentCoreReaders.cs      |   2 +-
 src/Lucene.Net/Index/SegmentDocValues.cs        |   6 +-
 src/Lucene.Net/Index/SegmentInfo.cs             |  81 +++---
 src/Lucene.Net/Index/SegmentInfos.cs            | 271 ++++++++++---------
 src/Lucene.Net/Index/SegmentMerger.cs           |  14 +-
 src/Lucene.Net/Index/SegmentReadState.cs        |  45 +--
 src/Lucene.Net/Index/SegmentReader.cs           |  73 ++---
 src/Lucene.Net/Index/SegmentWriteState.cs       |  41 +--
 src/Lucene.Net/Index/SerialMergeScheduler.cs    |   4 +-
 .../Index/SimpleMergedSegmentWarmer.cs          |   4 +-
 src/Lucene.Net/Index/SingleTermsEnum.cs         |   8 +-
 .../Index/SingletonSortedSetDocValues.cs        |  10 +-
 .../Index/SlowCompositeReaderWrapper.cs         |  18 +-
 src/Lucene.Net/Index/SnapshotDeletionPolicy.cs  |  70 ++---
 src/Lucene.Net/Index/SortedDocValues.cs         |  25 +-
 .../Index/SortedDocValuesTermsEnum.cs           |   6 +-
 src/Lucene.Net/Index/SortedDocValuesWriter.cs   | 142 +---------
 src/Lucene.Net/Index/SortedSetDocValues.cs      |  29 +-
 .../Index/SortedSetDocValuesTermsEnum.cs        |   6 +-
 .../Index/SortedSetDocValuesWriter.cs           | 229 +---------------
 src/Lucene.Net/Index/StandardDirectoryReader.cs |   6 +-
 src/Lucene.Net/Index/StoredFieldVisitor.cs      |  32 +--
 src/Lucene.Net/Index/StoredFieldsProcessor.cs   |   2 +-
 src/Lucene.Net/Index/TaskMergeScheduler.cs      |  70 ++---
 src/Lucene.Net/Index/Term.cs                    |  52 ++--
 src/Lucene.Net/Index/TermContext.cs             |  63 ++---
 src/Lucene.Net/Index/TermState.cs               |  15 +-
 src/Lucene.Net/Index/TermVectorsConsumer.cs     |   2 +-
 .../Index/TermVectorsConsumerPerField.cs        |   7 +-
 src/Lucene.Net/Index/Terms.cs                   |  87 +++---
 src/Lucene.Net/Index/TermsEnum.cs               |  70 ++---
 src/Lucene.Net/Index/TermsHash.cs               |  14 +-
 .../Index/TermsHashConsumerPerField.cs          |   8 +-
 src/Lucene.Net/Index/TermsHashPerField.cs       |  10 +-
 .../ThreadAffinityDocumentsWriterThreadPool.cs  |  16 +-
 src/Lucene.Net/Index/TieredMergePolicy.cs       |   2 +-
 src/Lucene.Net/Index/TrackingIndexWriter.cs     | 104 +++----
 src/Lucene.Net/Index/TwoPhaseCommit.cs          |  14 +-
 src/Lucene.Net/Index/TwoPhaseCommitTool.cs      |  35 +--
 .../Index/TwoStoredFieldsConsumers.cs           |   2 +-
 src/Lucene.Net/Index/UpgradeIndexMergePolicy.cs |  53 ++--
 71 files changed, 1143 insertions(+), 1739 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/lucenenet/blob/646db0ce/CONTRIBUTING.md
----------------------------------------------------------------------
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 4c3522b..c42e0bc 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -52,10 +52,9 @@ helpers to help with that, see for examples see our [Java style methods to avoid
 
 1. Lucene.Net.Core (project)
    1. Codecs (namespace)
-   2. Index (namespace) (Except for types starting with letter A-L and TieredMergePolicy)
-   3. Search (namespace)
-   4. Support (namespace)
-   5. Util (namespace) (Except for Util.Fst)
+   2. Search (namespace)
+   3. Support (namespace)
+   4. Util (namespace) (Except for Util.Fst)
 2. Lucene.Net.Codecs (project)
 
 See [Documenting Lucene.Net](https://cwiki.apache.org/confluence/display/LUCENENET/Documenting+Lucene.Net) for instructions. 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/646db0ce/src/Lucene.Net/Index/MergePolicy.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Index/MergePolicy.cs b/src/Lucene.Net/Index/MergePolicy.cs
index 72e2d68..20c0949 100644
--- a/src/Lucene.Net/Index/MergePolicy.cs
+++ b/src/Lucene.Net/Index/MergePolicy.cs
@@ -34,30 +34,30 @@ namespace Lucene.Net.Index
     //using AlreadySetException = Lucene.Net.Util.SetOnce.AlreadySetException;
 
     /// <summary>
-    /// <p>Expert: a MergePolicy determines the sequence of
-    /// primitive merge operations.</p>
+    /// <para>Expert: a <see cref="MergePolicy"/> determines the sequence of
+    /// primitive merge operations.</para>
     ///
-    /// <p>Whenever the segments in an index have been altered by
-    /// <seealso cref="IndexWriter"/>, either the addition of a newly
+    /// <para>Whenever the segments in an index have been altered by
+    /// <see cref="IndexWriter"/>, either the addition of a newly
     /// flushed segment, addition of many segments from
-    /// addIndexes* calls, or a previous merge that may now need
-    /// to cascade, <seealso cref="IndexWriter"/> invokes {@link
-    /// #findMerges} to give the MergePolicy a chance to pick
-    /// merges that are now required.  this method returns a
-    /// <seealso cref="MergeSpecification"/> instance describing the set of
+    /// AddIndexes* calls, or a previous merge that may now need
+    /// to cascade, <see cref="IndexWriter"/> invokes <see cref="FindMerges(MergeTrigger, SegmentInfos)"/>
+    /// to give the <see cref="MergePolicy"/> a chance to pick
+    /// merges that are now required.  This method returns a
+    /// <see cref="MergeSpecification"/> instance describing the set of
     /// merges that should be done, or null if no merges are
-    /// necessary.  When IndexWriter.forceMerge is called, it calls
-    /// <seealso cref="#findForcedMerges(SegmentInfos,int,Map)"/> and the MergePolicy should
-    /// then return the necessary merges.</p>
+    /// necessary.  When <see cref="IndexWriter.ForceMerge(int)"/> is called, it calls
+    /// <see cref="FindForcedMerges(SegmentInfos, int, IDictionary{SegmentCommitInfo, bool?})"/> and the <see cref="MergePolicy"/> should
+    /// then return the necessary merges.</para>
     ///
-    /// <p>Note that the policy can return more than one merge at
-    /// a time.  In this case, if the writer is using {@link
-    /// SerialMergeScheduler}, the merges will be run
-    /// sequentially but if it is using {@link
-    /// ConcurrentMergeScheduler} they will be run concurrently.</p>
+    /// <para>Note that the policy can return more than one merge at
+    /// a time.  In this case, if the writer is using 
+    /// <see cref="SerialMergeScheduler"/>, the merges will be run
+    /// sequentially but if it is using
+    /// <see cref="ConcurrentMergeScheduler"/> they will be run concurrently.</para>
     ///
-    /// <p>The default MergePolicy is {@link
-    /// TieredMergePolicy}.</p>
+    /// <para>The default MergePolicy is
+    /// <see cref="TieredMergePolicy"/>.</para>
     ///
     /// @lucene.experimental
     /// </summary>
@@ -131,7 +131,6 @@ namespace Lucene.Net.Index
             /// Estimated size in bytes of the merged segment. </summary>
             public long EstimatedMergeBytes { get; internal set; } // used by IndexWriter // LUCENENET NOTE: original was volatile, but long cannot be in .NET
 
-
             // Sum of sizeInBytes of all SegmentInfos; set by IW.mergeInit
             internal long totalMergeBytes; // LUCENENET NOTE: original was volatile, but long cannot be in .NET
 
@@ -172,8 +171,8 @@ namespace Lucene.Net.Index
             /// <summary>
             /// Expert: Get the list of readers to merge. Note that this list does not
             ///  necessarily match the list of segments to merge and should only be used
-            ///  to feed SegmentMerger to initialize a merge. When a <seealso cref="OneMerge"/>
-            ///  reorders doc IDs, it must override <seealso cref="#getDocMap"/> too so that
+            ///  to feed SegmentMerger to initialize a merge. When a <see cref="OneMerge"/>
+            ///  reorders doc IDs, it must override <see cref="GetDocMap"/> too so that
             ///  deletes that happened during the merge can be applied to the newly
             ///  merged segment.
             /// </summary>
@@ -195,7 +194,7 @@ namespace Lucene.Net.Index
             }
 
             /// <summary>
-            /// Expert: Sets the <seealso cref="SegmentCommitInfo"/> of this <seealso cref="OneMerge"/>.
+            /// Expert: Sets the <see cref="SegmentCommitInfo"/> of this <see cref="OneMerge"/>.
             /// Allows sub-classes to e.g. set diagnostics properties.
             /// </summary>
             public virtual SegmentCommitInfo Info
@@ -211,11 +210,11 @@ namespace Lucene.Net.Index
             }
 
             /// <summary>
-            /// Expert: If <seealso cref="#getMergeReaders()"/> reorders document IDs, this method
-            ///  must be overridden to return a mapping from the <i>natural</i> doc ID
-            ///  (the doc ID that would result from a natural merge) to the actual doc
-            ///  ID. this mapping is used to apply deletions that happened during the
-            ///  merge to the new segment.
+            /// Expert: If <see cref="GetMergeReaders()"/> reorders document IDs, this method
+            /// must be overridden to return a mapping from the <i>natural</i> doc ID
+            /// (the doc ID that would result from a natural merge) to the actual doc
+            /// ID. This mapping is used to apply deletions that happened during the
+            /// merge to the new segment.
             /// </summary>
             public virtual DocMap GetDocMap(MergeState mergeState)
             {
@@ -239,7 +238,7 @@ namespace Lucene.Net.Index
 
             /// <summary>
             /// Record that an exception occurred while executing
-            ///  this merge
+            /// this merge
             /// </summary>
             internal virtual Exception Exception
             {
@@ -261,8 +260,8 @@ namespace Lucene.Net.Index
 
             /// <summary>
             /// Mark this merge as aborted.  If this is called
-            ///  before the merge is committed then the merge will
-            ///  not be committed.
+            /// before the merge is committed then the merge will
+            /// not be committed.
             /// </summary>
             internal virtual void Abort()
             {
@@ -274,7 +273,7 @@ namespace Lucene.Net.Index
             }
 
             /// <summary>
-            /// Returns true if this merge was aborted. </summary>
+            /// Returns <c>true</c> if this merge was aborted. </summary>
             internal virtual bool IsAborted
             {
                 get
@@ -287,8 +286,8 @@ namespace Lucene.Net.Index
             }
 
             /// <summary>
-            /// Called periodically by <seealso cref="IndexWriter"/> while
-            ///  merging to see if the merge is aborted.
+            /// Called periodically by <see cref="IndexWriter"/> while
+            /// merging to see if the merge is aborted.
             /// </summary>
             public virtual void CheckAborted(Directory dir)
             {
@@ -325,8 +324,8 @@ namespace Lucene.Net.Index
 
             /// <summary>
             /// Set or clear whether this merge is paused paused (for example
-            ///  <seealso cref="ConcurrentMergeScheduler"/> will pause merges
-            ///  if too many are running).
+            /// <see cref="ConcurrentMergeScheduler"/> will pause merges
+            /// if too many are running).
             /// </summary>
             internal virtual void SetPause(bool paused)
             {
@@ -342,7 +341,7 @@ namespace Lucene.Net.Index
             }
 
             /// <summary>
-            /// Returns true if this merge is paused.
+            /// Returns <c>true</c> if this merge is paused.
             /// </summary>
             /// <seealso cref="SetPause(bool)"/>
             internal virtual bool IsPaused
@@ -358,7 +357,7 @@ namespace Lucene.Net.Index
 
             /// <summary>
             /// Returns a readable description of the current merge
-            ///  state.
+            /// state.
             /// </summary>
             public virtual string SegString(Directory dir)
             {
@@ -390,8 +389,8 @@ namespace Lucene.Net.Index
             /// <summary>
             /// Returns the total size in bytes of this merge. Note that this does not
             /// indicate the size of the merged segment, but the
-            /// input total size. this is only set once the merge is
-            /// initialized by IndexWriter.
+            /// input total size. This is only set once the merge is
+            /// initialized by <see cref="IndexWriter"/>.
             /// </summary>
             public virtual long TotalBytesSize
             {
@@ -401,7 +400,6 @@ namespace Lucene.Net.Index
             /// <summary>
             /// Returns the total number of documents that are included with this merge.
             /// Note that this does not indicate the number of documents after the merge.
-            ///
             /// </summary>
             public virtual int TotalNumDocs
             {
@@ -417,7 +415,7 @@ namespace Lucene.Net.Index
             }
 
             /// <summary>
-            /// Return <seealso cref="MergeInfo"/> describing this merge. </summary>
+            /// Return <see cref="Store.MergeInfo"/> describing this merge. </summary>
             public virtual MergeInfo MergeInfo
             {
                 get
@@ -428,9 +426,9 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// A MergeSpecification instance provides the information
+        /// A <see cref="MergeSpecification"/> instance provides the information
         /// necessary to perform multiple merges.  It simply
-        /// contains a list of <seealso cref="OneMerge"/> instances.
+        /// contains a list of <see cref="OneMerge"/> instances.
         /// </summary>
 #if FEATURE_SERIALIZABLE
         [Serializable]
@@ -440,12 +438,11 @@ namespace Lucene.Net.Index
             /// <summary>
             /// The subset of segments to be included in the primitive merge.
             /// </summary>
-
             public IList<OneMerge> Merges { get; private set; }
 
             /// <summary>
-            /// Sole constructor.  Use {@link
-            ///  #add(MergePolicy.OneMerge)} to add merges.
+            /// Sole constructor.  Use 
+            /// <see cref="Add(OneMerge)"/> to add merges.
             /// </summary>
             public MergeSpecification()
             {
@@ -453,8 +450,8 @@ namespace Lucene.Net.Index
             }
 
             /// <summary>
-            /// Adds the provided <seealso cref="OneMerge"/> to this
-            ///  specification.
+            /// Adds the provided <see cref="OneMerge"/> to this
+            /// specification.
             /// </summary>
             public virtual void Add(OneMerge merge)
             {
@@ -463,7 +460,7 @@ namespace Lucene.Net.Index
 
             /// <summary>
             /// Returns a description of the merges in this
-            ///  specification.
+            /// specification.
             /// </summary>
             public virtual string SegString(Directory dir)
             {
@@ -480,7 +477,7 @@ namespace Lucene.Net.Index
 
         /// <summary>
         /// Exception thrown if there are any problems while
-        ///  executing a merge.
+        /// executing a merge.
         /// </summary>
         // LUCENENET: All exeption classes should be marked serializable
 #if FEATURE_SERIALIZABLE
@@ -525,8 +522,8 @@ namespace Lucene.Net.Index
 #endif
 
             /// <summary>
-            /// Returns the <seealso cref="Directory"/> of the index that hit
-            ///  the exception.
+            /// Returns the <see cref="Store.Directory"/> of the index that hit
+            /// the exception.
             /// </summary>
             public virtual Directory Directory
             {
@@ -539,9 +536,9 @@ namespace Lucene.Net.Index
 
         /// <summary>
         /// Thrown when a merge was explicity aborted because
-        ///  <seealso cref="IndexWriter#close(boolean)"/> was called with
-        ///  <code>false</code>.  Normally this exception is
-        ///  privately caught and suppresed by <seealso cref="IndexWriter"/>.
+        /// <see cref="IndexWriter.Dispose(bool)"/> was called with
+        /// <c>false</c>.  Normally this exception is
+        /// privately caught and suppresed by <see cref="IndexWriter"/>.
         /// </summary>
         // LUCENENET: All exeption classes should be marked serializable
 #if FEATURE_SERIALIZABLE
@@ -550,15 +547,15 @@ namespace Lucene.Net.Index
         public class MergeAbortedException : System.IO.IOException
         {
             /// <summary>
-            /// Create a <seealso cref="MergeAbortedException"/>. </summary>
+            /// Create a <see cref="MergeAbortedException"/>. </summary>
             public MergeAbortedException()
                 : base("merge is aborted")
             {
             }
 
             /// <summary>
-            /// Create a <seealso cref="MergeAbortedException"/> with a
-            ///  specified message.
+            /// Create a <see cref="MergeAbortedException"/> with a
+            /// specified message.
             /// </summary>
             public MergeAbortedException(string message)
                 : base(message)
@@ -579,30 +576,30 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Default ratio for compound file system usage. Set to <tt>1.0</tt>, always use
+        /// Default ratio for compound file system usage. Set to <c>1.0</c>, always use
         /// compound file system.
         /// </summary>
         protected static readonly double DEFAULT_NO_CFS_RATIO = 1.0;
 
         /// <summary>
-        /// Default max segment size in order to use compound file system. Set to <seealso cref="Long#MAX_VALUE"/>.
+        /// Default max segment size in order to use compound file system. Set to <see cref="long.MaxValue"/>.
         /// </summary>
         protected static readonly long DEFAULT_MAX_CFS_SEGMENT_SIZE = long.MaxValue;
 
         /// <summary>
-        /// <seealso cref="IndexWriter"/> that contains this instance. </summary>
+        /// <see cref="IndexWriter"/> that contains this instance. </summary>
         protected SetOnce<IndexWriter> m_writer;
 
         /// <summary>
         /// If the size of the merge segment exceeds this ratio of
-        ///  the total index size then it will remain in
-        ///  non-compound format
+        /// the total index size then it will remain in
+        /// non-compound format
         /// </summary>
         protected double m_noCFSRatio = DEFAULT_NO_CFS_RATIO;
 
         /// <summary>
         /// If the size of the merged segment exceeds
-        ///  this value then it will not use compound file format.
+        /// this value then it will not use compound file format.
         /// </summary>
         protected long m_maxCFSSegmentSize = DEFAULT_MAX_CFS_SEGMENT_SIZE;
 
@@ -617,8 +614,8 @@ namespace Lucene.Net.Index
 
         /// <summary>
         /// Creates a new merge policy instance. Note that if you intend to use it
-        /// without passing it to <seealso cref="IndexWriter"/>, you should call
-        /// <seealso cref="#setIndexWriter(IndexWriter)"/>.
+        /// without passing it to <see cref="IndexWriter"/>, you should call
+        /// <see cref="SetIndexWriter(IndexWriter)"/>.
         /// </summary>
         public MergePolicy()
             : this(DEFAULT_NO_CFS_RATIO, DEFAULT_MAX_CFS_SEGMENT_SIZE)
@@ -626,9 +623,9 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Creates a new merge policy instance with default settings for noCFSRatio
-        /// and maxCFSSegmentSize. this ctor should be used by subclasses using different
-        /// defaults than the <seealso cref="MergePolicy"/>
+        /// Creates a new merge policy instance with default settings for <see cref="m_noCFSRatio"/>
+        /// and <see cref="m_maxCFSSegmentSize"/>. This ctor should be used by subclasses using different
+        /// defaults than the <see cref="MergePolicy"/>
         /// </summary>
         protected MergePolicy(double defaultNoCFSRatio, long defaultMaxCFSSegmentSize)
         {
@@ -638,11 +635,11 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Sets the <seealso cref="IndexWriter"/> to use by this merge policy. this method is
-        /// allowed to be called only once, and is usually set by IndexWriter. If it is
-        /// called more than once, <seealso cref="AlreadySetException"/> is thrown.
+        /// Sets the <see cref="IndexWriter"/> to use by this merge policy. This method is
+        /// allowed to be called only once, and is usually set by <see cref="IndexWriter"/>. If it is
+        /// called more than once, <see cref="AlreadySetException"/> is thrown.
         /// </summary>
-        /// <seealso cref= SetOnce </seealso>
+        /// <seealso cref="SetOnce{T}"/>
         public virtual void SetIndexWriter(IndexWriter writer)
         {
             this.m_writer.Set(writer);
@@ -651,7 +648,7 @@ namespace Lucene.Net.Index
         /// <summary>
         /// Determine what set of merge operations are now necessary on the index.
         /// <see cref="IndexWriter"/> calls this whenever there is a change to the segments.
-        /// this call is always synchronized on the <see cref="IndexWriter"/> instance so
+        /// This call is always synchronized on the <see cref="IndexWriter"/> instance so
         /// only one thread at a time will call this method. </summary>
         /// <param name="mergeTrigger"> the event that triggered the merge </param>
         /// <param name="segmentInfos">
@@ -661,20 +658,20 @@ namespace Lucene.Net.Index
         /// <summary>
         /// Determine what set of merge operations is necessary in
         /// order to merge to &lt;= the specified segment count. <see cref="IndexWriter"/> calls this when its
-        /// <see cref="IndexWriter.ForceMerge"/> method is called. this call is always
+        /// <see cref="IndexWriter.ForceMerge(int, bool)"/> method is called. This call is always
         /// synchronized on the <see cref="IndexWriter"/> instance so only one thread at a
         /// time will call this method.
         /// </summary>
         /// <param name="segmentInfos">
-        ///          the total set of segments in the index </param>
+        ///          The total set of segments in the index </param>
         /// <param name="maxSegmentCount">
-        ///          requested maximum number of segments in the index (currently this
+        ///          Requested maximum number of segments in the index (currently this
         ///          is always 1) </param>
         /// <param name="segmentsToMerge">
-        ///          contains the specific SegmentInfo instances that must be merged
-        ///          away. this may be a subset of all
-        ///          SegmentInfos.  If the value is True for a
-        ///          given SegmentInfo, that means this segment was
+        ///          Contains the specific <see cref="SegmentInfo"/> instances that must be merged
+        ///          away. This may be a subset of all
+        ///          SegmentInfos.  If the value is <c>true</c> for a
+        ///          given <see cref="SegmentInfo"/>, that means this segment was
         ///          an original segment present in the
         ///          to-be-merged index; else, it was a segment
         ///          produced by a cascaded merge. </param>
@@ -704,11 +701,11 @@ namespace Lucene.Net.Index
         protected abstract void Dispose(bool disposing);
 
         /// <summary>
-        /// Returns true if a new segment (regardless of its origin) should use the
-        /// compound file format. The default implementation returns <code>true</code>
+        /// Returns <c>true</c> if a new segment (regardless of its origin) should use the
+        /// compound file format. The default implementation returns <c>true</c>
         /// iff the size of the given mergedInfo is less or equal to
-        /// <seealso cref="#getMaxCFSSegmentSizeMB()"/> and the size is less or equal to the
-        /// TotalIndexSize * <seealso cref="#getNoCFSRatio()"/> otherwise <code>false</code>.
+        /// <see cref="MaxCFSSegmentSizeMB"/> and the size is less or equal to the
+        /// TotalIndexSize * <see cref="NoCFSRatio"/> otherwise <code>false</code>.
         /// </summary>
         public virtual bool UseCompoundFile(SegmentInfos infos, SegmentCommitInfo mergedInfo)
         {
@@ -734,9 +731,9 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Return the byte size of the provided {@link
-        ///  SegmentCommitInfo}, pro-rated by percentage of
-        ///  non-deleted documents is set.
+        /// Return the byte size of the provided 
+        /// <see cref="SegmentCommitInfo"/>, pro-rated by percentage of
+        /// non-deleted documents is set.
         /// </summary>
         protected virtual long Size(SegmentCommitInfo info)
         {
@@ -748,9 +745,9 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Returns true if this single info is already fully merged (has no
-        ///  pending deletes, is in the same dir as the
-        ///  writer, and matches the current compound file setting
+        /// Returns <c>true</c> if this single info is already fully merged (has no
+        /// pending deletes, is in the same dir as the
+        /// writer, and matches the current compound file setting
         /// </summary>
         protected bool IsMerged(SegmentInfos infos, SegmentCommitInfo info)
         {
@@ -766,9 +763,14 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Returns current {@code noCFSRatio}.
+        /// Gets or Sets current <see cref="m_noCFSRatio"/>.
+        /// <para/>
+        /// If a merged segment will be more than this percentage
+        /// of the total size of the index, leave the segment as
+        /// non-compound file even if compound file is enabled.
+        /// Set to 1.0 to always use CFS regardless of merge
+        /// size.
         /// </summary>
-        ///  <seealso cref= #setNoCFSRatio  </seealso>
         public double NoCFSRatio
         {
             get
@@ -786,7 +788,14 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Returns the largest size allowed for a compound file segment </summary>
+        /// Gets or Sets the largest size allowed for a compound file segment.
+        /// <para/>
+        /// If a merged segment will be more than this value,
+        /// leave the segment as
+        /// non-compound file even if compound file is enabled.
+        /// Set this to <see cref="double.PositiveInfinity"/> (default) and <see cref="NoCFSRatio"/> to 1.0
+        /// to always use CFS regardless of merge size.
+        /// </summary>
         public double MaxCFSSegmentSizeMB
         {
             get

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/646db0ce/src/Lucene.Net/Index/MergeScheduler.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Index/MergeScheduler.cs b/src/Lucene.Net/Index/MergeScheduler.cs
index 224c44b..cdd1225 100644
--- a/src/Lucene.Net/Index/MergeScheduler.cs
+++ b/src/Lucene.Net/Index/MergeScheduler.cs
@@ -20,13 +20,13 @@ namespace Lucene.Net.Index
      */
 
     /// <summary>
-    /// <p>Expert: <seealso cref="IndexWriter"/> uses an instance
-    ///  implementing this interface to execute the merges
-    ///  selected by a <seealso cref="MergePolicy"/>.  The default
-    ///  MergeScheduler is <seealso cref="ConcurrentMergeScheduler"/>.</p>
-    ///  <p>Implementers of sub-classes should make sure that <seealso cref="#clone()"/>
-    ///  returns an independent instance able to work with any <seealso cref="IndexWriter"/>
-    ///  instance.</p>
+    /// <para>Expert: <see cref="IndexWriter"/> uses an instance
+    /// implementing this interface to execute the merges
+    /// selected by a <see cref="MergePolicy"/>.  The default
+    /// MergeScheduler is <see cref="ConcurrentMergeScheduler"/>.</para>
+    /// <para>Implementers of sub-classes should make sure that <see cref="Clone()"/>
+    /// returns an independent instance able to work with any <see cref="IndexWriter"/>
+    /// instance.</para>
     /// @lucene.experimental
     /// </summary>
 #if FEATURE_SERIALIZABLE
@@ -36,7 +36,7 @@ namespace Lucene.Net.Index
     {
         /// <summary>
         /// Sole constructor. (For invocation by subclass
-        ///  constructors, typically implicit.)
+        /// constructors, typically implicit.)
         /// </summary>
         protected MergeScheduler()
         {
@@ -50,6 +50,8 @@ namespace Lucene.Net.Index
         ///  </param>
         public abstract void Merge(IndexWriter writer, MergeTrigger trigger, bool newMergesFound);
 
+        /// <summary>
+        /// Dispose this MergeScheduler. </summary>
         public void Dispose()
         {
             Dispose(true);
@@ -57,7 +59,7 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Close this MergeScheduler. </summary>
+        /// Dispose this MergeScheduler. </summary>
         protected abstract void Dispose(bool disposing);
 
         public virtual IMergeScheduler Clone()

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/646db0ce/src/Lucene.Net/Index/MergeState.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Index/MergeState.cs b/src/Lucene.Net/Index/MergeState.cs
index 45d5526..942e2b9 100644
--- a/src/Lucene.Net/Index/MergeState.cs
+++ b/src/Lucene.Net/Index/MergeState.cs
@@ -30,7 +30,7 @@ namespace Lucene.Net.Index
 
     /// <summary>
     /// Holds common state used during segment merging.
-    ///
+    /// <para/>
     /// @lucene.experimental
     /// </summary>
 #if FEATURE_SERIALIZABLE
@@ -53,7 +53,7 @@ namespace Lucene.Net.Index
 
             /// <summary>
             /// Returns the total number of documents, ignoring
-            ///  deletions.
+            /// deletions.
             /// </summary>
             public abstract int MaxDoc { get; }
 
@@ -69,15 +69,15 @@ namespace Lucene.Net.Index
             public abstract int NumDeletedDocs { get; }
 
             /// <summary>
-            /// Returns true if there are any deletions. </summary>
+            /// Returns <c>true</c> if there are any deletions. </summary>
             public virtual bool HasDeletions
             {
                 get { return NumDeletedDocs > 0; }
             }
 
             /// <summary>
-            /// Creates a <seealso cref="DocMap"/> instance appropriate for
-            ///  this reader.
+            /// Creates a <see cref="DocMap"/> instance appropriate for
+            /// this reader.
             /// </summary>
             public static DocMap Build(AtomicReader reader)
             {
@@ -171,11 +171,11 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// <seealso cref="SegmentInfo"/> of the newly merged segment. </summary>
+        /// <see cref="Index.SegmentInfo"/> of the newly merged segment. </summary>
         public SegmentInfo SegmentInfo { get; private set; }
 
         /// <summary>
-        /// <seealso cref="FieldInfos"/> of the newly merged segment. </summary>
+        /// <see cref="Index.FieldInfos"/> of the newly merged segment. </summary>
         public FieldInfos FieldInfos { get; set; }
 
         /// <summary>
@@ -195,20 +195,20 @@ namespace Lucene.Net.Index
         public int[] DocBase { get; set; }
 
         /// <summary>
-        /// Holds the CheckAbort instance, which is invoked
-        ///  periodically to see if the merge has been aborted.
+        /// Holds the <see cref="Index.CheckAbort"/> instance, which is invoked
+        /// periodically to see if the merge has been aborted.
         /// </summary>
         public CheckAbort CheckAbort { get; private set; }
 
         /// <summary>
-        /// InfoStream for debugging messages. </summary>
+        /// <see cref="Util.InfoStream"/> for debugging messages. </summary>
         public InfoStream InfoStream { get; private set; }
 
         // TODO: get rid of this? it tells you which segments are 'aligned' (e.g. for bulk merging)
         // but is this really so expensive to compute again in different components, versus once in SM?
 
         /// <summary>
-        /// <seealso cref="SegmentReader"/>s that have identical field
+        /// <see cref="SegmentReader"/>s that have identical field
         /// name/number mapping, so their stored fields and term
         /// vectors may be bulk merged.
         /// </summary>
@@ -217,7 +217,7 @@ namespace Lucene.Net.Index
         public SegmentReader[] MatchingSegmentReaders { get; set; }
 
         /// <summary>
-        /// How many <seealso cref="#matchingSegmentReaders"/> are set. </summary>
+        /// How many <see cref="MatchingSegmentReaders"/> are set. </summary>
         public int MatchedCount { get; set; }
 
         /// <summary>
@@ -241,7 +241,7 @@ namespace Lucene.Net.Index
         private readonly Directory dir;
 
         /// <summary>
-        /// Creates a #CheckAbort instance. </summary>
+        /// Creates a <see cref="CheckAbort"/> instance. </summary>
         public CheckAbort(MergePolicy.OneMerge merge, Directory dir)
         {
             this.merge = merge;
@@ -251,9 +251,9 @@ namespace Lucene.Net.Index
         /// <summary>
         /// Records the fact that roughly units amount of work
         /// have been done since this method was last called.
-        /// When adding time-consuming code into SegmentMerger,
+        /// When adding time-consuming code into <see cref="SegmentMerger"/>,
         /// you should test different values for units to ensure
-        /// that the time in between calls to merge.checkAborted
+        /// that the time in between calls to merge.CheckAborted
         /// is up to ~ 1 second.
         /// </summary>
         public virtual void Work(double units)
@@ -267,7 +267,8 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// If you use this: IW.close(false) cannot abort your merge!
+        /// If you use this: IW.Dispose(false) cannot abort your merge!
+        /// <para/>
         /// @lucene.internal
         /// </summary>
         public static readonly CheckAbort NONE = new CheckAbortAnonymousInnerClassHelper();

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/646db0ce/src/Lucene.Net/Index/MergeTrigger.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Index/MergeTrigger.cs b/src/Lucene.Net/Index/MergeTrigger.cs
index 113be31..ea8c80c 100644
--- a/src/Lucene.Net/Index/MergeTrigger.cs
+++ b/src/Lucene.Net/Index/MergeTrigger.cs
@@ -18,7 +18,7 @@ namespace Lucene.Net.Index
      */
 
     /// <summary>
-    /// MergeTrigger is passed to
+    /// <see cref="MergeTrigger"/> is passed to
     /// <see cref="MergePolicy.FindMerges(MergeTrigger, SegmentInfos)"/> to indicate the
     /// event that triggered the merge.
     /// </summary>
@@ -31,7 +31,7 @@ namespace Lucene.Net.Index
 
         /// <summary>
         /// Merge was triggered by a full flush. Full flushes
-        /// can be caused by a commit, NRT reader reopen or a close call on the index writer.
+        /// can be caused by a commit, NRT reader reopen or a <see cref="IndexWriter.Dispose()"/> call on the index writer.
         /// </summary>
         FULL_FLUSH,
 
@@ -46,7 +46,7 @@ namespace Lucene.Net.Index
         MERGE_FINISHED,
 
         /// <summary>
-        /// Merge was triggered by a closing IndexWriter.
+        /// Merge was triggered by a disposing <see cref="IndexWriter"/>.
         /// </summary>
         CLOSING
     }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/646db0ce/src/Lucene.Net/Index/MultiBits.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Index/MultiBits.cs b/src/Lucene.Net/Index/MultiBits.cs
index 3ac7e67..1894d1f 100644
--- a/src/Lucene.Net/Index/MultiBits.cs
+++ b/src/Lucene.Net/Index/MultiBits.cs
@@ -24,11 +24,11 @@ namespace Lucene.Net.Index
     using IBits = Lucene.Net.Util.IBits;
 
     /// <summary>
-    /// Concatenates multiple Bits together, on every lookup.
+    /// Concatenates multiple <see cref="IBits"/> together, on every lookup.
     ///
-    /// <p><b>NOTE</b>: this is very costly, as every lookup must
+    /// <para/><b>NOTE</b>: this is very costly, as every lookup must
     /// do a binary search to locate the right sub-reader.
-    ///
+    /// <para/>
     /// @lucene.experimental
     /// </summary>
 #if FEATURE_SERIALIZABLE
@@ -99,7 +99,7 @@ namespace Lucene.Net.Index
 
         /// <summary>
         /// Represents a sub-Bits from
-        /// <seealso cref="MultiBits#getMatchingSub(Lucene.Net.Index.ReaderSlice) getMatchingSub()"/>.
+        /// <see cref="MultiBits.GetMatchingSub(Lucene.Net.Index.ReaderSlice)"/>.
         /// </summary>
         public sealed class SubResult
         {
@@ -108,11 +108,11 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Returns a sub-Bits matching the provided <code>slice</code>
-        /// <p>
-        /// Because <code>null</code> usually has a special meaning for
-        /// Bits (e.g. no deleted documents), you must check
-        /// <seealso cref="SubResult#matches"/> instead to ensure the sub was
+        /// Returns a sub-Bits matching the provided <paramref name="slice"/>
+        /// <para/>
+        /// Because <c>null</c> usually has a special meaning for
+        /// <see cref="IBits"/> (e.g. no deleted documents), you must check
+        /// <see cref="SubResult.Matches"/> instead to ensure the sub was
         /// actually found.
         /// </summary>
         public SubResult GetMatchingSub(ReaderSlice slice)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/646db0ce/src/Lucene.Net/Index/MultiDocValues.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Index/MultiDocValues.cs b/src/Lucene.Net/Index/MultiDocValues.cs
index f97a672..1a542f0 100644
--- a/src/Lucene.Net/Index/MultiDocValues.cs
+++ b/src/Lucene.Net/Index/MultiDocValues.cs
@@ -32,16 +32,17 @@ namespace Lucene.Net.Index
     using TermsEnumWithSlice = Lucene.Net.Index.MultiTermsEnum.TermsEnumWithSlice;
 
     /// <summary>
-    /// A wrapper for CompositeIndexReader providing access to DocValues.
+    /// A wrapper for <see cref="CompositeReader"/> providing access to <see cref="DocValues"/>.
     ///
-    /// <p><b>NOTE</b>: for multi readers, you'll get better
+    /// <para/><b>NOTE</b>: for multi readers, you'll get better
     /// performance by gathering the sub readers using
-    /// <seealso cref="IndexReader#getContext()"/> to get the
+    /// <see cref="IndexReader.Context"/> to get the
     /// atomic leaves and then operate per-AtomicReader,
     /// instead of using this class.
     ///
-    /// <p><b>NOTE</b>: this is very costly.
+    /// <para/><b>NOTE</b>: this is very costly.
     ///
+    /// <para/>
     /// @lucene.experimental
     /// @lucene.internal
     /// </summary>
@@ -57,11 +58,11 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Returns a NumericDocValues for a reader's norms (potentially merging on-the-fly).
-        /// <p>
-        /// this is a slow way to access normalization values. Instead, access them per-segment
-        /// with <seealso cref="AtomicReader#getNormValues(String)"/>
-        /// </p>
+        /// Returns a <see cref="NumericDocValues"/> for a reader's norms (potentially merging on-the-fly).
+        /// <para>
+        /// This is a slow way to access normalization values. Instead, access them per-segment
+        /// with <seealso cref="AtomicReader.GetNormValues(string)"/>
+        /// </para>
         /// </summary>
         public static NumericDocValues GetNormValues(IndexReader r, string field)
         {
@@ -128,12 +129,11 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Returns a NumericDocValues for a reader's docvalues (potentially merging on-the-fly)
-        /// <p>
-        /// this is a slow way to access numeric values. Instead, access them per-segment
-        /// with <seealso cref="AtomicReader#getNumericDocValues(String)"/>
-        /// </p>
-        ///
+        /// Returns a <see cref="NumericDocValues"/> for a reader's docvalues (potentially merging on-the-fly)
+        /// <para>
+        /// This is a slow way to access numeric values. Instead, access them per-segment
+        /// with <see cref="AtomicReader.GetNumericDocValues(string)"/>
+        /// </para>
         /// </summary>
         public static NumericDocValues GetNumericValues(IndexReader r, string field)
         {
@@ -200,12 +200,11 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Returns a Bits for a reader's docsWithField (potentially merging on-the-fly)
-        /// <p>
-        /// this is a slow way to access this bitset. Instead, access them per-segment
-        /// with <seealso cref="AtomicReader#getDocsWithField(String)"/>
-        /// </p>
-        ///
+        /// Returns a <see cref="IBits"/> for a reader's docsWithField (potentially merging on-the-fly)
+        /// <para>
+        /// This is a slow way to access this bitset. Instead, access them per-segment
+        /// with <see cref="AtomicReader.GetDocsWithField(string)"/>
+        /// </para>
         /// </summary>
         public static IBits GetDocsWithField(IndexReader r, string field)
         {
@@ -261,11 +260,11 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Returns a BinaryDocValues for a reader's docvalues (potentially merging on-the-fly)
-        /// <p>
-        /// this is a slow way to access binary values. Instead, access them per-segment
-        /// with <seealso cref="AtomicReader#getBinaryDocValues(String)"/>
-        /// </p>
+        /// Returns a <see cref="BinaryDocValues"/> for a reader's docvalues (potentially merging on-the-fly)
+        /// <para>
+        /// This is a slow way to access binary values. Instead, access them per-segment
+        /// with <see cref="AtomicReader.GetBinaryDocValues(string)"/>
+        /// </para>
         /// </summary>
         public static BinaryDocValues GetBinaryValues(IndexReader r, string field)
         {
@@ -333,11 +332,11 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Returns a SortedDocValues for a reader's docvalues (potentially doing extremely slow things).
-        /// <p>
+        /// Returns a <see cref="SortedDocValues"/> for a reader's docvalues (potentially doing extremely slow things).
+        /// <para>
         /// this is an extremely slow way to access sorted values. Instead, access them per-segment
-        /// with <seealso cref="AtomicReader#getSortedDocValues(String)"/>
-        /// </p>
+        /// with <see cref="AtomicReader.GetSortedDocValues(string)"/>
+        /// </para>
         /// </summary>
         public static SortedDocValues GetSortedValues(IndexReader r, string field)
         {
@@ -390,11 +389,11 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Returns a SortedSetDocValues for a reader's docvalues (potentially doing extremely slow things).
-        /// <p>
-        /// this is an extremely slow way to access sorted values. Instead, access them per-segment
-        /// with <seealso cref="AtomicReader#getSortedSetDocValues(String)"/>
-        /// </p>
+        /// Returns a <see cref="SortedSetDocValues"/> for a reader's docvalues (potentially doing extremely slow things).
+        /// <para>
+        /// This is an extremely slow way to access sorted values. Instead, access them per-segment
+        /// with <see cref="AtomicReader.GetSortedSetDocValues(string)"/>
+        /// </para>
         /// </summary>
         public static SortedSetDocValues GetSortedSetValues(IndexReader r, string field)
         {
@@ -469,11 +468,11 @@ namespace Lucene.Net.Index
 
             /// <summary>
             /// Creates an ordinal map that allows mapping ords to/from a merged
-            /// space from <code>subs</code>. </summary>
+            /// space from <c>subs</c>. </summary>
             /// <param name="owner"> a cache key </param>
-            /// <param name="subs"> TermsEnums that support <seealso cref="TermsEnum#ord()"/>. They need
-            ///             not be dense (e.g. can be FilteredTermsEnums}. </param>
-            /// <exception cref="IOException"> if an I/O error occurred. </exception>
+            /// <param name="subs"> <see cref="TermsEnum"/>s that support <see cref="TermsEnum.Ord"/>. They need
+            ///             not be dense (e.g. can be FilteredTermsEnums). </param>
+            /// <exception cref="System.IO.IOException"> if an I/O error occurred. </exception>
             public OrdinalMap(object owner, TermsEnum[] subs)
             {
                 // create the ordinal mappings by pulling a termsenum over each sub's
@@ -539,7 +538,7 @@ namespace Lucene.Net.Index
 
             /// <summary>
             /// Given global ordinal, returns the ordinal of the first segment which contains
-            /// this ordinal (the corresponding to the segment return <seealso cref="#getFirstSegmentNumber"/>).
+            /// this ordinal (the corresponding to the segment return <see cref="GetFirstSegmentNumber(long)"/>).
             /// </summary>
             public virtual long GetFirstSegmentOrd(long globalOrd)
             {
@@ -581,7 +580,8 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Implements SortedDocValues over n subs, using an OrdinalMap
+        /// Implements <see cref="SortedDocValues"/> over n subs, using an <see cref="OrdinalMap"/>
+        /// <para/>
         /// @lucene.internal
         /// </summary>
 #if FEATURE_SERIALIZABLE
@@ -590,7 +590,7 @@ namespace Lucene.Net.Index
         public class MultiSortedDocValues : SortedDocValues
         {
             /// <summary>
-            /// docbase for each leaf: parallel with <seealso cref="#values"/> </summary>
+            /// docbase for each leaf: parallel with <see cref="Values"/> </summary>
             [WritableArray]
             [SuppressMessage("Microsoft.Performance", "CA1819", Justification = "Lucene's design requires some writable array properties")]
             public int[] DocStarts
@@ -610,7 +610,7 @@ namespace Lucene.Net.Index
             private readonly SortedDocValues[] values;
 
             /// <summary>
-            /// ordinal map mapping ords from <code>values</code> to global ord space </summary>
+            /// ordinal map mapping ords from <c>values</c> to global ord space </summary>
             public OrdinalMap Mapping
             {
                 get { return mapping; }
@@ -618,7 +618,7 @@ namespace Lucene.Net.Index
             private readonly OrdinalMap mapping;
 
             /// <summary>
-            /// Creates a new MultiSortedDocValues over <code>values</code> </summary>
+            /// Creates a new <see cref="MultiSortedDocValues"/> over <paramref name="values"/> </summary>
             internal MultiSortedDocValues(SortedDocValues[] values, int[] docStarts, OrdinalMap mapping)
             {
                 Debug.Assert(values.Length == mapping.ordDeltas.Length);
@@ -652,7 +652,8 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Implements MultiSortedSetDocValues over n subs, using an OrdinalMap
+        /// Implements <see cref="MultiSortedSetDocValues"/> over n subs, using an <see cref="OrdinalMap"/>
+        /// <para/>
         /// @lucene.internal
         /// </summary>
 #if FEATURE_SERIALIZABLE
@@ -661,7 +662,7 @@ namespace Lucene.Net.Index
         public class MultiSortedSetDocValues : SortedSetDocValues
         {
             /// <summary>
-            /// docbase for each leaf: parallel with <seealso cref="#values"/> </summary>
+            /// docbase for each leaf: parallel with <see cref="Values"/> </summary>
             [WritableArray]
             [SuppressMessage("Microsoft.Performance", "CA1819", Justification = "Lucene's design requires some writable array properties")]
             public int[] DocStarts
@@ -681,7 +682,7 @@ namespace Lucene.Net.Index
             private readonly SortedSetDocValues[] values;
 
             /// <summary>
-            /// ordinal map mapping ords from <code>values</code> to global ord space </summary>
+            /// ordinal map mapping ords from <c>values</c> to global ord space </summary>
             public OrdinalMap Mapping
             {
                 get { return mapping; } 
@@ -691,7 +692,7 @@ namespace Lucene.Net.Index
             internal int currentSubIndex;
 
             /// <summary>
-            /// Creates a new MultiSortedSetDocValues over <code>values</code> </summary>
+            /// Creates a new <see cref="MultiSortedSetDocValues"/> over <paramref name="values"/> </summary>
             internal MultiSortedSetDocValues(SortedSetDocValues[] values, int[] docStarts, OrdinalMap mapping)
             {
                 Debug.Assert(values.Length == mapping.ordDeltas.Length);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/646db0ce/src/Lucene.Net/Index/MultiDocsAndPositionsEnum.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Index/MultiDocsAndPositionsEnum.cs b/src/Lucene.Net/Index/MultiDocsAndPositionsEnum.cs
index bfab6d7..b8092bf 100644
--- a/src/Lucene.Net/Index/MultiDocsAndPositionsEnum.cs
+++ b/src/Lucene.Net/Index/MultiDocsAndPositionsEnum.cs
@@ -26,7 +26,7 @@ namespace Lucene.Net.Index
 
     /// <summary>
     /// Exposes flex API, merged from flex API of sub-segments.
-    ///
+    /// <para/>
     /// @lucene.experimental
     /// </summary>
 #if FEATURE_SERIALIZABLE
@@ -52,8 +52,8 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Returns {@code true} if this instance can be reused by
-        ///  the provided <seealso cref="MultiTermsEnum"/>.
+        /// Returns <c>true</c> if this instance can be reused by
+        /// the provided <see cref="MultiTermsEnum"/>.
         /// </summary>
         public bool CanReuse(MultiTermsEnum parent)
         {
@@ -61,7 +61,7 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Rre-use and reset this instance on the provided slices. </summary>
+        /// Re-use and reset this instance on the provided slices. </summary>
         public MultiDocsAndPositionsEnum Reset(EnumWithSlice[] subs, int numSubs)
         {
             this.numSubs = numSubs;
@@ -80,7 +80,7 @@ namespace Lucene.Net.Index
 
         /// <summary>
         /// How many sub-readers we are merging. </summary>
-        ///  <seealso cref= #getSubs  </seealso>
+        /// <see cref="Subs"/>
         public int NumSubs
         {
             get
@@ -203,8 +203,8 @@ namespace Lucene.Net.Index
 
         // TODO: implement bulk read more efficiently than super
         /// <summary>
-        /// Holds a <seealso cref="DocsAndPositionsEnum"/> along with the
-        ///  corresponding <seealso cref="ReaderSlice"/>.
+        /// Holds a <see cref="Index.DocsAndPositionsEnum"/> along with the
+        /// corresponding <see cref="ReaderSlice"/>.
         /// </summary>
 #if FEATURE_SERIALIZABLE
         [Serializable]
@@ -216,12 +216,12 @@ namespace Lucene.Net.Index
             }
 
             /// <summary>
-            /// <seealso cref="DocsAndPositionsEnum"/> for this sub-reader. </summary>
+            /// <see cref="Index.DocsAndPositionsEnum"/> for this sub-reader. </summary>
             public DocsAndPositionsEnum DocsAndPositionsEnum { get; internal set; } // LUCENENET NOTE: Made setter internal because ctor is internal
 
             /// <summary>
-            /// <seealso cref="ReaderSlice"/> describing how this sub-reader
-            ///  fits into the composite reader.
+            /// <see cref="ReaderSlice"/> describing how this sub-reader
+            /// fits into the composite reader.
             /// </summary>
             public ReaderSlice Slice { get; internal set; } // LUCENENET NOTE: Made setter internal because ctor is internal
 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/646db0ce/src/Lucene.Net/Index/MultiDocsEnum.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Index/MultiDocsEnum.cs b/src/Lucene.Net/Index/MultiDocsEnum.cs
index 0e34a7c..d1e2e8a 100644
--- a/src/Lucene.Net/Index/MultiDocsEnum.cs
+++ b/src/Lucene.Net/Index/MultiDocsEnum.cs
@@ -23,9 +23,9 @@ namespace Lucene.Net.Index
      */
 
     /// <summary>
-    /// Exposes <seealso cref="DocsEnum"/>, merged from <seealso cref="DocsEnum"/>
+    /// Exposes <see cref="DocsEnum"/>, merged from <see cref="DocsEnum"/>
     /// API of sub-segments.
-    ///
+    /// <para/>
     /// @lucene.experimental
     /// </summary>
 #if FEATURE_SERIALIZABLE
@@ -44,7 +44,7 @@ namespace Lucene.Net.Index
 
         /// <summary>
         /// Sole constructor </summary>
-        /// <param name="parent"> The <seealso cref="MultiTermsEnum"/> that created us. </param>
+        /// <param name="parent"> The <see cref="MultiTermsEnum"/> that created us. </param>
         /// <param name="subReaderCount"> How many sub-readers are being merged.  </param>
         public MultiDocsEnum(MultiTermsEnum parent, int subReaderCount)
         {
@@ -70,8 +70,8 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Returns {@code true} if this instance can be reused by
-        ///  the provided <seealso cref="MultiTermsEnum"/>.
+        /// Returns <c>true</c> if this instance can be reused by
+        /// the provided <see cref="MultiTermsEnum"/>.
         /// </summary>
         public bool CanReuse(MultiTermsEnum parent)
         {
@@ -80,7 +80,7 @@ namespace Lucene.Net.Index
 
         /// <summary>
         /// How many sub-readers we are merging. </summary>
-        ///  <seealso cref= #getSubs  </seealso>
+        /// <seealso cref="Subs"/>
         public int NumSubs
         {
             get
@@ -189,8 +189,8 @@ namespace Lucene.Net.Index
 
         // TODO: implement bulk read more efficiently than super
         /// <summary>
-        /// Holds a <seealso cref="DocsEnum"/> along with the
-        ///  corresponding <seealso cref="ReaderSlice"/>.
+        /// Holds a <see cref="Index.DocsEnum"/> along with the
+        /// corresponding <see cref="ReaderSlice"/>.
         /// </summary>
 #if FEATURE_SERIALIZABLE
         [Serializable]
@@ -202,12 +202,12 @@ namespace Lucene.Net.Index
             }
 
             /// <summary>
-            /// <seealso cref="DocsEnum"/> of this sub-reader. </summary>
+            /// <see cref="Index.DocsEnum"/> of this sub-reader. </summary>
             public DocsEnum DocsEnum { get; internal set; } // LUCENENET NOTE: Made setter internal because ctor is internal
 
             /// <summary>
-            /// <seealso cref="ReaderSlice"/> describing how this sub-reader
-            ///  fits into the composite reader.
+            /// <see cref="ReaderSlice"/> describing how this sub-reader
+            /// fits into the composite reader.
             /// </summary>
             public ReaderSlice Slice { get; internal set; } // LUCENENET NOTE: Made setter internal because ctor is internal
 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/646db0ce/src/Lucene.Net/Index/MultiFields.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Index/MultiFields.cs b/src/Lucene.Net/Index/MultiFields.cs
index 045200b..b5e750c 100644
--- a/src/Lucene.Net/Index/MultiFields.cs
+++ b/src/Lucene.Net/Index/MultiFields.cs
@@ -29,17 +29,17 @@ namespace Lucene.Net.Index
 
     /// <summary>
     /// Exposes flex API, merged from flex API of sub-segments.
-    /// this is useful when you're interacting with an {@link
-    /// IndexReader} implementation that consists of sequential
-    /// sub-readers (eg <seealso cref="DirectoryReader"/> or {@link
-    /// MultiReader}).
+    /// This is useful when you're interacting with an 
+    /// <see cref="IndexReader"/> implementation that consists of sequential
+    /// sub-readers (eg <see cref="DirectoryReader"/> or 
+    /// <see cref="MultiReader"/>).
     ///
-    /// <p><b>NOTE</b>: for composite readers, you'll get better
+    /// <para/><b>NOTE</b>: for composite readers, you'll get better
     /// performance by gathering the sub readers using
-    /// <seealso cref="IndexReader#getContext()"/> to get the
+    /// <see cref="IndexReader.Context"/> to get the
     /// atomic leaves and then operate per-AtomicReader,
     /// instead of using this class.
-    ///
+    /// <para/>
     /// @lucene.experimental
     /// </summary>
 #if FEATURE_SERIALIZABLE
@@ -52,14 +52,14 @@ namespace Lucene.Net.Index
         private readonly IDictionary<string, Terms> terms = new ConcurrentDictionary<string, Terms>();
 
         /// <summary>
-        /// Returns a single <seealso cref="Fields"/> instance for this
-        ///  reader, merging fields/terms/docs/positions on the
-        ///  fly.  this method will return null if the reader
-        ///  has no postings.
+        /// Returns a single <see cref="Fields"/> instance for this
+        /// reader, merging fields/terms/docs/positions on the
+        /// fly.  This method will return <c>null</c> if the reader
+        /// has no postings.
         ///
-        ///  <p><b>NOTE</b>: this is a slow way to access postings.
-        ///  It's better to get the sub-readers and iterate through them
-        ///  yourself.
+        /// <para/><b>NOTE</b>: this is a slow way to access postings.
+        /// It's better to get the sub-readers and iterate through them
+        /// yourself.
         /// </summary>
         public static Fields GetFields(IndexReader reader)
         {
@@ -103,15 +103,15 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Returns a single <seealso cref="IBits"/> instance for this
-        ///  reader, merging live Documents on the
-        ///  fly.  this method will return null if the reader
-        ///  has no deletions.
+        /// Returns a single <see cref="IBits"/> instance for this
+        /// reader, merging live Documents on the
+        /// fly.  This method will return <c>null</c> if the reader
+        /// has no deletions.
         ///
-        ///  <p><b>NOTE</b>: this is a very slow way to access live docs.
-        ///  For example, each Bits access will require a binary search.
-        ///  It's better to get the sub-readers and iterate through them
-        ///  yourself.
+        /// <para/><b>NOTE</b>: this is a very slow way to access live docs.
+        /// For example, each <see cref="IBits"/> access will require a binary search.
+        /// It's better to get the sub-readers and iterate through them
+        /// yourself.
         /// </summary>
         public static IBits GetLiveDocs(IndexReader reader)
         {
@@ -143,7 +143,7 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        ///  this method may return null if the field does not exist. </summary>
+        /// this method may return <c>null</c> if the field does not exist. </summary>
         public static Terms GetTerms(IndexReader r, string field)
         {
             Fields fields = GetFields(r);
@@ -158,9 +158,9 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Returns <seealso cref="DocsEnum"/> for the specified field &
-        ///  term.  this will return null if the field or term does
-        ///  not exist.
+        /// Returns <see cref="DocsEnum"/> for the specified field &amp;
+        /// term.  This will return <c>null</c> if the field or term does
+        /// not exist.
         /// </summary>
         public static DocsEnum GetTermDocsEnum(IndexReader r, IBits liveDocs, string field, BytesRef term)
         {
@@ -168,12 +168,12 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Returns <seealso cref="DocsEnum"/> for the specified field &
-        ///  term, with control over whether freqs are required.
-        ///  Some codecs may be able to optimize their
-        ///  implementation when freqs are not required.  this will
-        ///  return null if the field or term does not exist.  See {@link
-        ///  TermsEnum#docs(Bits,DocsEnum,int)}.
+        /// Returns <see cref="DocsEnum"/> for the specified field &amp;
+        /// term, with control over whether freqs are required.
+        /// Some codecs may be able to optimize their
+        /// implementation when freqs are not required.  This will
+        /// return <c>null</c> if the field or term does not exist.  See
+        /// <see cref="TermsEnum.Docs(IBits, DocsEnum, DocsFlags)"/>.
         /// </summary>
         public static DocsEnum GetTermDocsEnum(IndexReader r, IBits liveDocs, string field, BytesRef term, DocsFlags flags)
         {
@@ -192,23 +192,23 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Returns <seealso cref="DocsAndPositionsEnum"/> for the specified
-        ///  field & term.  this will return null if the field or
-        ///  term does not exist or positions were not indexed. </summary>
-        ///  <seealso cref= #getTermPositionsEnum(IndexReader, Bits, String, BytesRef, int)  </seealso>
+        /// Returns <see cref="DocsAndPositionsEnum"/> for the specified
+        /// field &amp; term.  This will return <c>null</c> if the field or
+        /// term does not exist or positions were not indexed. </summary>
+        /// <seealso cref="GetTermPositionsEnum(IndexReader, IBits, string, BytesRef, DocsAndPositionsFlags)"/>
         public static DocsAndPositionsEnum GetTermPositionsEnum(IndexReader r, IBits liveDocs, string field, BytesRef term)
         {
             return GetTermPositionsEnum(r, liveDocs, field, term, DocsAndPositionsFlags.OFFSETS | DocsAndPositionsFlags.PAYLOADS);
         }
 
         /// <summary>
-        /// Returns <seealso cref="DocsAndPositionsEnum"/> for the specified
-        ///  field & term, with control over whether offsets and payloads are
-        ///  required.  Some codecs may be able to optimize
-        ///  their implementation when offsets and/or payloads are not
-        ///  required. this will return null if the field or term does not
-        ///  exist or positions were not indexed. See {@link
-        ///  TermsEnum#docsAndPositions(Bits,DocsAndPositionsEnum,int)}.
+        /// Returns <see cref="DocsAndPositionsEnum"/> for the specified
+        /// field &amp; term, with control over whether offsets and payloads are
+        /// required.  Some codecs may be able to optimize
+        /// their implementation when offsets and/or payloads are not
+        /// required. This will return <c>null</c> if the field or term does not
+        /// exist or positions were not indexed. See 
+        /// <see cref="TermsEnum.DocsAndPositions(IBits, DocsAndPositionsEnum, DocsAndPositionsFlags)"/>.
         /// </summary>
         public static DocsAndPositionsEnum GetTermPositionsEnum(IndexReader r, IBits liveDocs, string field, BytesRef term, DocsAndPositionsFlags flags)
         {
@@ -227,7 +227,8 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Expert: construct a new MultiFields instance directly.
+        /// Expert: construct a new <see cref="MultiFields"/> instance directly.
+        /// <para/>
         /// @lucene.internal
         /// </summary>
         // TODO: why is this public?
@@ -291,13 +292,13 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Call this to get the (merged) FieldInfos for a
-        ///  composite reader.
-        ///  <p>
-        ///  NOTE: the returned field numbers will likely not
-        ///  correspond to the actual field numbers in the underlying
-        ///  readers, and codec metadata (<seealso cref="FieldInfo#getAttribute(String)"/>
-        ///  will be unavailable.
+        /// Call this to get the (merged) <see cref="FieldInfos"/> for a
+        /// composite reader.
+        /// <para/>
+        /// NOTE: the returned field numbers will likely not
+        /// correspond to the actual field numbers in the underlying
+        /// readers, and codec metadata (<see cref="FieldInfo.GetAttribute(string)"/>)
+        /// will be unavailable.
         /// </summary>
         public static FieldInfos GetMergedFieldInfos(IndexReader reader)
         {
@@ -310,13 +311,13 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Call this to get the (merged) FieldInfos representing the
-        ///  set of indexed fields <b>only</b> for a composite reader.
-        ///  <p>
-        ///  NOTE: the returned field numbers will likely not
-        ///  correspond to the actual field numbers in the underlying
-        ///  readers, and codec metadata (<seealso cref="FieldInfo#getAttribute(String)"/>
-        ///  will be unavailable.
+        /// Call this to get the (merged) <see cref="FieldInfos"/> representing the
+        /// set of indexed fields <b>only</b> for a composite reader.
+        /// <para/>
+        /// NOTE: the returned field numbers will likely not
+        /// correspond to the actual field numbers in the underlying
+        /// readers, and codec metadata (<see cref="FieldInfo.GetAttribute(string)"/>)
+        /// will be unavailable.
         /// </summary>
         public static ICollection<string> GetIndexedFields(IndexReader reader)
         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/646db0ce/src/Lucene.Net/Index/MultiReader.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Index/MultiReader.cs b/src/Lucene.Net/Index/MultiReader.cs
index 2be292a..9cafc9c 100644
--- a/src/Lucene.Net/Index/MultiReader.cs
+++ b/src/Lucene.Net/Index/MultiReader.cs
@@ -21,22 +21,22 @@ namespace Lucene.Net.Index
      */
 
     /// <summary>
-    /// A <seealso cref="CompositeReader"/> which reads multiple indexes, appending
-    ///  their content. It can be used to create a view on several
-    ///  sub-readers (like <seealso cref="DirectoryReader"/>) and execute searches on it.
+    /// A <see cref="CompositeReader"/> which reads multiple indexes, appending
+    /// their content. It can be used to create a view on several
+    /// sub-readers (like <see cref="DirectoryReader"/>) and execute searches on it.
     ///
-    /// <p> For efficiency, in this API documents are often referred to via
+    /// <para/> For efficiency, in this API documents are often referred to via
     /// <i>document numbers</i>, non-negative integers which each name a unique
     /// document in the index.  These document numbers are ephemeral -- they may change
     /// as documents are added to and deleted from an index.  Clients should thus not
     /// rely on a given document having the same number between sessions.
     ///
-    /// <p><a name="thread-safety"></a><p><b>NOTE</b>: {@link
-    /// IndexReader} instances are completely thread
+    /// <para/><a name="thread-safety"></a><b>NOTE</b>: 
+    /// <see cref="IndexReader"/> instances are completely thread
     /// safe, meaning multiple threads can call any of its methods,
     /// concurrently.  If your application requires external
     /// synchronization, you should <b>not</b> synchronize on the
-    /// <code>IndexReader</code> instance; use your own
+    /// <see cref="IndexReader"/> instance; use your own
     /// (non-Lucene) objects instead.
     /// </summary>
 #if FEATURE_SERIALIZABLE
@@ -47,8 +47,8 @@ namespace Lucene.Net.Index
         private readonly bool closeSubReaders;
 
         /// <summary>
-        /// <p>Construct a MultiReader aggregating the named set of (sub)readers.
-        /// <p>Note that all subreaders are closed if this Multireader is closed.</p> </summary>
+        /// <para>Construct a <see cref="MultiReader"/> aggregating the named set of (sub)readers.</para>
+        /// <para>Note that all subreaders are closed if this Multireader is closed.</para> </summary>
         /// <param name="subReaders"> set of (sub)readers </param>
         public MultiReader(params IndexReader[] subReaders)
             : this(subReaders, true)
@@ -56,10 +56,10 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// <p>Construct a MultiReader aggregating the named set of (sub)readers. </summary>
+        /// Construct a <see cref="MultiReader"/> aggregating the named set of (sub)readers. </summary>
         /// <param name="subReaders"> set of (sub)readers; this array will be cloned. </param>
-        /// <param name="closeSubReaders"> indicates whether the subreaders should be closed
-        /// when this MultiReader is closed </param>
+        /// <param name="closeSubReaders"> indicates whether the subreaders should be disposed
+        /// when this <see cref="MultiReader"/> is disposed </param>
         public MultiReader(IndexReader[] subReaders, bool closeSubReaders)
             : base((IndexReader[])subReaders.Clone())
         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/646db0ce/src/Lucene.Net/Index/MultiTerms.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Index/MultiTerms.cs b/src/Lucene.Net/Index/MultiTerms.cs
index 6854182..d6370a7 100644
--- a/src/Lucene.Net/Index/MultiTerms.cs
+++ b/src/Lucene.Net/Index/MultiTerms.cs
@@ -28,7 +28,7 @@ namespace Lucene.Net.Index
     /// <summary>
     /// Exposes flex API, merged from flex API of
     /// sub-segments.
-    ///
+    /// <para/>
     /// @lucene.experimental
     /// </summary>
 #if FEATURE_SERIALIZABLE
@@ -47,9 +47,9 @@ namespace Lucene.Net.Index
         /// <summary>
         /// Sole constructor.
         /// </summary>
-        /// <param name="subs"> The <seealso cref="Terms"/> instances of all sub-readers. </param>
-        /// <param name="subSlices"> A parallel array (matching {@code
-        ///        subs}) describing the sub-reader slices. </param>
+        /// <param name="subs"> The <see cref="Terms"/> instances of all sub-readers. </param>
+        /// <param name="subSlices"> A parallel array (matching 
+        ///        <paramref name="subs"/>) describing the sub-reader slices. </param>
         public MultiTerms(Terms[] subs, ReaderSlice[] subSlices)
         {
             this.subs = subs;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/646db0ce/src/Lucene.Net/Index/MultiTermsEnum.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Index/MultiTermsEnum.cs b/src/Lucene.Net/Index/MultiTermsEnum.cs
index 813897a..7fda1de 100644
--- a/src/Lucene.Net/Index/MultiTermsEnum.cs
+++ b/src/Lucene.Net/Index/MultiTermsEnum.cs
@@ -27,9 +27,9 @@ namespace Lucene.Net.Index
     using BytesRef = Lucene.Net.Util.BytesRef;
 
     /// <summary>
-    /// Exposes <seealso cref="TermsEnum"/> API, merged from <seealso cref="TermsEnum"/> API of sub-segments.
-    /// this does a merge sort, by term text, of the sub-readers.
-    ///
+    /// Exposes <see cref="TermsEnum"/> API, merged from <see cref="TermsEnum"/> API of sub-segments.
+    /// This does a merge sort, by term text, of the sub-readers.
+    /// <para/>
     /// @lucene.experimental
     /// </summary>
 #if FEATURE_SERIALIZABLE
@@ -70,8 +70,9 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Returns how many sub-reader slices contain the current </summary>
-        ///  term.  <seealso cref= #getMatchArray  </seealso>
+        /// Returns how many sub-reader slices contain the current 
+        /// term.</summary> 
+        /// <seealso cref="MatchArray"/>
         public int MatchCount
         {
             get
@@ -91,8 +92,8 @@ namespace Lucene.Net.Index
 
         /// <summary>
         /// Sole constructor. </summary>
-        ///  <param name="slices"> Which sub-reader slices we should
-        ///  merge.  </param>
+        /// <param name="slices"> Which sub-reader slices we should
+        /// merge.</param>
         public MultiTermsEnum(ReaderSlice[] slices)
         {
             queue = new TermMergeQueue(slices.Length);
@@ -125,8 +126,8 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// The terms array must be newly created TermsEnum, ie
-        ///  <seealso cref="TermsEnum#next"/> has not yet been called.
+        /// The terms array must be newly created <see cref="TermsEnum"/>, ie
+        /// <see cref="TermsEnum.Next()"/> has not yet been called.
         /// </summary>
         public TermsEnum Reset(TermsEnumIndex[] termsEnumsIndex)
         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/646db0ce/src/Lucene.Net/Index/NoDeletionPolicy.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Index/NoDeletionPolicy.cs b/src/Lucene.Net/Index/NoDeletionPolicy.cs
index e36a523..865abeb 100644
--- a/src/Lucene.Net/Index/NoDeletionPolicy.cs
+++ b/src/Lucene.Net/Index/NoDeletionPolicy.cs
@@ -21,9 +21,9 @@ namespace Lucene.Net.Index
      */
 
     /// <summary>
-    /// An <seealso cref="IndexDeletionPolicy"/> which keeps all index commits around, never
-    /// deleting them. this class is a singleton and can be accessed by referencing
-    /// <seealso cref="#INSTANCE"/>.
+    /// An <see cref="IndexDeletionPolicy"/> which keeps all index commits around, never
+    /// deleting them. This class is a singleton and can be accessed by referencing
+    /// <see cref="INSTANCE"/>.
     /// </summary>
 #if FEATURE_SERIALIZABLE
     [Serializable]

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/646db0ce/src/Lucene.Net/Index/NoMergePolicy.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Index/NoMergePolicy.cs b/src/Lucene.Net/Index/NoMergePolicy.cs
index beb702c..d137a22 100644
--- a/src/Lucene.Net/Index/NoMergePolicy.cs
+++ b/src/Lucene.Net/Index/NoMergePolicy.cs
@@ -21,11 +21,11 @@ namespace Lucene.Net.Index
      */
 
     /// <summary>
-    /// A <seealso cref="MergePolicy"/> which never returns merges to execute (hence it's
+    /// A <see cref="MergePolicy"/> which never returns merges to execute (hence it's
     /// name). It is also a singleton and can be accessed through
-    /// <seealso cref="NoMergePolicy#NO_COMPOUND_FILES"/> if you want to indicate the index
-    /// does not use compound files, or through <seealso cref="NoMergePolicy#COMPOUND_FILES"/>
-    /// otherwise. Use it if you want to prevent an <seealso cref="IndexWriter"/> from ever
+    /// <see cref="NoMergePolicy.NO_COMPOUND_FILES"/> if you want to indicate the index
+    /// does not use compound files, or through <see cref="NoMergePolicy.COMPOUND_FILES"/>
+    /// otherwise. Use it if you want to prevent an <see cref="IndexWriter"/> from ever
     /// executing merges, without going through the hassle of tweaking a merge
     /// policy's settings to achieve that, such as changing its merge factor.
     /// </summary>
@@ -35,13 +35,13 @@ namespace Lucene.Net.Index
     public sealed class NoMergePolicy : MergePolicy
     {
         /// <summary>
-        /// A singleton <seealso cref="NoMergePolicy"/> which indicates the index does not use
+        /// A singleton <see cref="NoMergePolicy"/> which indicates the index does not use
         /// compound files.
         /// </summary>
         public static readonly MergePolicy NO_COMPOUND_FILES = new NoMergePolicy(false);
 
         /// <summary>
-        /// A singleton <seealso cref="NoMergePolicy"/> which indicates the index uses compound
+        /// A singleton <see cref="NoMergePolicy"/> which indicates the index uses compound
         /// files.
         /// </summary>
         public static readonly MergePolicy COMPOUND_FILES = new NoMergePolicy(true);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/646db0ce/src/Lucene.Net/Index/NoMergeScheduler.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Index/NoMergeScheduler.cs b/src/Lucene.Net/Index/NoMergeScheduler.cs
index 020e8df..4283b78 100644
--- a/src/Lucene.Net/Index/NoMergeScheduler.cs
+++ b/src/Lucene.Net/Index/NoMergeScheduler.cs
@@ -23,10 +23,10 @@ namespace Lucene.Net.Index
     /// A <see cref="MergeScheduler"/> which never executes any merges. It is also a
     /// singleton and can be accessed through <see cref="NoMergeScheduler.INSTANCE"/>. Use
     /// it if you want to prevent an <see cref="IndexWriter"/> from ever executing merges,
-    /// regardless of the <seealso cref="MergePolicy"/> used. Note that you can achieve the
-    /// same thing by using <seealso cref="NoMergePolicy"/>, however with
-    /// <seealso cref="NoMergeScheduler"/> you also ensure that no unnecessary code of any
-    /// <seealso cref="MergeScheduler"/> implementation is ever executed. Hence it is
+    /// regardless of the <see cref="MergePolicy"/> used. Note that you can achieve the
+    /// same thing by using <see cref="NoMergePolicy"/>, however with
+    /// <see cref="NoMergeScheduler"/> you also ensure that no unnecessary code of any
+    /// <see cref="MergeScheduler"/> implementation is ever executed. Hence it is
     /// recommended to use both if you want to disable merges from ever happening.
     /// </summary>
 #if FEATURE_SERIALIZABLE
@@ -35,7 +35,7 @@ namespace Lucene.Net.Index
     public sealed class NoMergeScheduler : MergeScheduler
     {
         /// <summary>
-        /// The single instance of <seealso cref="NoMergeScheduler"/> </summary>
+        /// The single instance of <see cref="NoMergeScheduler"/> </summary>
         public static readonly MergeScheduler INSTANCE = new NoMergeScheduler();
 
         private NoMergeScheduler()

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/646db0ce/src/Lucene.Net/Index/NormsConsumer.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Index/NormsConsumer.cs b/src/Lucene.Net/Index/NormsConsumer.cs
index e0437e0..444cd6c 100644
--- a/src/Lucene.Net/Index/NormsConsumer.cs
+++ b/src/Lucene.Net/Index/NormsConsumer.cs
@@ -29,8 +29,8 @@ namespace Lucene.Net.Index
 
     /// <summary>
     /// Writes norms.  Each thread X field accumulates the norms
-    ///  for the doc/fields it saw, then the flush method below
-    ///  merges all of these together into a single _X.nrm file.
+    /// for the doc/fields it saw, then the flush method below
+    /// merges all of these together into a single _X.nrm file.
     /// </summary>
 #if FEATURE_SERIALIZABLE
     [Serializable]

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/646db0ce/src/Lucene.Net/Index/NumericDocValuesFieldUpdates.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Index/NumericDocValuesFieldUpdates.cs b/src/Lucene.Net/Index/NumericDocValuesFieldUpdates.cs
index 3b627d9..7d09541 100644
--- a/src/Lucene.Net/Index/NumericDocValuesFieldUpdates.cs
+++ b/src/Lucene.Net/Index/NumericDocValuesFieldUpdates.cs
@@ -30,9 +30,9 @@ namespace Lucene.Net.Index
     using PagedMutable = Lucene.Net.Util.Packed.PagedMutable;
 
     /// <summary>
-    /// A <seealso cref="DocValuesFieldUpdates"/> which holds updates of documents, of a single
-    /// <seealso cref="NumericDocValuesField"/>.
-    ///
+    /// A <see cref="DocValuesFieldUpdates"/> which holds updates of documents, of a single
+    /// <see cref="NumericDocValuesField"/>.
+    /// <para/>
     /// @lucene.experimental
     /// </summary>
 #if FEATURE_SERIALIZABLE

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/646db0ce/src/Lucene.Net/Index/NumericDocValuesWriter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Index/NumericDocValuesWriter.cs b/src/Lucene.Net/Index/NumericDocValuesWriter.cs
index fdfbccc..ae9e1e2 100644
--- a/src/Lucene.Net/Index/NumericDocValuesWriter.cs
+++ b/src/Lucene.Net/Index/NumericDocValuesWriter.cs
@@ -30,7 +30,7 @@ namespace Lucene.Net.Index
 
     /// <summary>
     /// Buffers up pending long per doc, then flushes when
-    ///  segment flushes.
+    /// segment flushes.
     /// </summary>
 #if FEATURE_SERIALIZABLE
     [Serializable]
@@ -134,96 +134,8 @@ namespace Lucene.Net.Index
             }
         }
 
-        /*
-	  private class IterableAnonymousInnerClassHelper : IEnumerable<Number>
-	  {
-		  private readonly NumericDocValuesWriter OuterInstance;
-
-		  private int MaxDoc;
-
-		  public IterableAnonymousInnerClassHelper(NumericDocValuesWriter outerInstance, int maxDoc)
-		  {
-			  this.OuterInstance = outerInstance;
-			  this.MaxDoc = maxDoc;
-		  }
-
-		  public virtual IEnumerator<Number> GetEnumerator()
-		  {
-			return new NumericIterator(OuterInstance, MaxDoc);
-		  }
-	  }*/
-
         public override void Abort()
         {
         }
-
-        /*
-	  // iterates over the values we have in ram
-	  private class NumericIterator : IEnumerator<Number>
-	  {
-		  internal bool InstanceFieldsInitialized = false;
-
-		  internal virtual void InitializeInstanceFields()
-		  {
-			  Iter = OuterInstance.Pending.Iterator();
-			  Size = (int)OuterInstance.Pending.Size();
-		  }
-
-		  private readonly NumericDocValuesWriter OuterInstance;
-
-		internal AppendingDeltaPackedLongBuffer.Iterator Iter;
-		internal int Size;
-		internal readonly int MaxDoc;
-		internal int Upto;
-
-		internal NumericIterator(NumericDocValuesWriter outerInstance, int maxDoc)
-		{
-			this.OuterInstance = outerInstance;
-
-			if (!InstanceFieldsInitialized)
-			{
-				InitializeInstanceFields();
-				InstanceFieldsInitialized = true;
-			}
-		  this.MaxDoc = maxDoc;
-		}
-
-		public override bool HasNext()
-		{
-		  return Upto < MaxDoc;
-		}
-
-		public override Number Next()
-		{
-		  if (!HasNext())
-		  {
-			throw new NoSuchElementException();
-		  }
-		  long? value;
-		  if (Upto < Size)
-		  {
-			long v = Iter.next();
-            if (OuterInstance.DocsWithField == null || OuterInstance.DocsWithField.Get(Upto))
-			{
-			  value = v;
-			}
-			else
-			{
-			  value = null;
-			}
-		  }
-		  else
-		  {
-              value = OuterInstance.DocsWithField != null ? null : MISSING;
-		  }
-		  Upto++;
-		  return value;
-		}
-
-		public override void Remove()
-		{
-		  throw new System.NotSupportedException();
-		}
-	  }*/
     }
 }
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/646db0ce/src/Lucene.Net/Index/OrdTermState.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Index/OrdTermState.cs b/src/Lucene.Net/Index/OrdTermState.cs
index 7a9a2ed..4383d1c 100644
--- a/src/Lucene.Net/Index/OrdTermState.cs
+++ b/src/Lucene.Net/Index/OrdTermState.cs
@@ -21,8 +21,8 @@ namespace Lucene.Net.Index
      */
 
     /// <summary>
-    /// An ordinal based <seealso cref="TermState"/>
-    ///
+    /// An ordinal based <see cref="TermState"/>
+    /// <para/>
     /// @lucene.experimental
     /// </summary>
 #if FEATURE_SERIALIZABLE
@@ -32,7 +32,7 @@ namespace Lucene.Net.Index
     {
         /// <summary>
         /// Term ordinal, i.e. it's position in the full list of
-        ///  sorted terms.
+        /// sorted terms.
         /// </summary>
         public long Ord { get; set; }
 


Mime
View raw message