lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From nightowl...@apache.org
Subject [36/45] lucenenet git commit: Lucene.Net.Index: types starting with letter F - fixed documentation comments
Date Sun, 30 Apr 2017 21:56:15 GMT
Lucene.Net.Index: types starting with letter F - fixed documentation comments


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

Branch: refs/heads/master
Commit: e6c2b88a2d8ad490a061294d19145fa7b3b31f88
Parents: 0ac91f5
Author: Shad Storhaug <shad@shadstorhaug.com>
Authored: Sat Apr 29 19:48:03 2017 +0700
Committer: Shad Storhaug <shad@shadstorhaug.com>
Committed: Mon May 1 04:48:37 2017 +0700

----------------------------------------------------------------------
 CONTRIBUTING.md                                 |  2 +-
 src/Lucene.Net/Index/FieldInfo.cs               | 30 +++----
 src/Lucene.Net/Index/FieldInfos.cs              | 48 ++++++-----
 src/Lucene.Net/Index/FieldInvertState.cs        | 32 +++----
 src/Lucene.Net/Index/Fields.cs                  | 31 ++++---
 src/Lucene.Net/Index/FilterAtomicReader.cs      | 88 ++++++++++----------
 src/Lucene.Net/Index/FilterDirectoryReader.cs   | 54 ++++++------
 src/Lucene.Net/Index/FilteredTermsEnum.cs       | 76 +++++++++--------
 .../Index/FlushByRamOrCountsPolicy.cs           | 85 ++++++++++---------
 src/Lucene.Net/Index/FlushPolicy.cs             | 78 ++++++++---------
 src/Lucene.Net/Index/FreqProxTermsWriter.cs     |  4 +-
 .../Index/FreqProxTermsWriterPerField.cs        |  9 +-
 src/Lucene.Net/Index/FrozenBufferedUpdates.cs   | 10 +--
 13 files changed, 277 insertions(+), 270 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/lucenenet/blob/e6c2b88a/CONTRIBUTING.md
----------------------------------------------------------------------
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index aa0ee26..713aa1a 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -52,7 +52,7 @@ 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-D, LiveIndexWriterConfig, IndexWriter, IndexWriterConfig, IndexReader, and TieredMergePolicy)
+   2. Index (namespace) (Except for types starting with letter A-F, IndexWriter, IndexWriterConfig, IndexReader, LiveIndexWriterConfig, and TieredMergePolicy)
    3. Search (namespace)
    4. Support (namespace)
    5. Util (namespace) (Except for Util.Fst)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/e6c2b88a/src/Lucene.Net/Index/FieldInfo.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Index/FieldInfo.cs b/src/Lucene.Net/Index/FieldInfo.cs
index e8cbb41..0d31307 100644
--- a/src/Lucene.Net/Index/FieldInfo.cs
+++ b/src/Lucene.Net/Index/FieldInfo.cs
@@ -27,7 +27,6 @@ namespace Lucene.Net.Index
     ///  of this class are thread-safe for multiple readers, but only one thread can
     ///  be adding documents at a time, with no other reader or writer threads
     ///  accessing this object.
-    ///
     /// </summary>
 #if FEATURE_SERIALIZABLE
     [Serializable]
@@ -61,7 +60,7 @@ namespace Lucene.Net.Index
 
         /// <summary>
         /// Sole Constructor.
-        ///
+        /// <para/>
         /// @lucene.experimental
         /// </summary>
         public FieldInfo(string name, bool indexed, int number, bool storeTermVector, bool omitNorms, 
@@ -183,7 +182,7 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Returns IndexOptions for the field, or null if the field is not indexed </summary>
+        /// Returns <see cref="Index.IndexOptions"/> for the field, or <c>null</c> if the field is not indexed </summary>
         public IndexOptions IndexOptions
         {
             get
@@ -193,7 +192,7 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Returns true if this field has any docValues.
+        /// Returns <c>true</c> if this field has any docValues.
         /// </summary>
         public bool HasDocValues
         {
@@ -201,7 +200,7 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Sets the docValues generation of this field. </summary>
+        /// Gets or Sets the docValues generation of this field, or -1 if no docValues. </summary>
         public long DocValuesGen
         {
             set
@@ -250,7 +249,7 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Returns true if norms are explicitly omitted for this field
+        /// Returns <c>true</c> if norms are explicitly omitted for this field
         /// </summary>
         public bool OmitsNorms
         {
@@ -258,7 +257,7 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Returns true if this field actually has any norms.
+        /// Returns <c>true</c> if this field actually has any norms.
         /// </summary>
         public bool HasNorms
         {
@@ -266,7 +265,7 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Returns true if this field is indexed.
+        /// Returns <c>true</c> if this field is indexed.
         /// </summary>
         public bool IsIndexed
         {
@@ -277,7 +276,7 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Returns true if any payloads exist for this field.
+        /// Returns <c>true</c> if any payloads exist for this field.
         /// </summary>
         public bool HasPayloads
         {
@@ -285,7 +284,7 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Returns true if any term vectors exist for this field.
+        /// Returns <c>true</c> if any term vectors exist for this field.
         /// </summary>
         public bool HasVectors
         {
@@ -293,7 +292,7 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Get a codec attribute value, or null if it does not exist
+        /// Get a codec attribute value, or <c>null</c> if it does not exist
         /// </summary>
         public string GetAttribute(string key)
         {
@@ -311,11 +310,11 @@ namespace Lucene.Net.Index
 
         /// <summary>
         /// Puts a codec attribute value.
-        /// <p>
+        /// <para/>
         /// this is a key-value mapping for the field that the codec can use
         /// to store additional metadata, and will be available to the codec
-        /// when reading the segment via <seealso cref="#getAttribute(String)"/>
-        /// <p>
+        /// when reading the segment via <see cref="GetAttribute(string)"/>
+        /// <para/>
         /// If a value already exists for the field, it will be replaced with
         /// the new value.
         /// </summary>
@@ -338,7 +337,7 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Returns internal codec attributes map. May be null if no mappings exist.
+        /// Returns internal codec attributes map. May be <c>null</c> if no mappings exist.
         /// </summary>
         public IDictionary<string, string> Attributes
         {
@@ -348,6 +347,7 @@ namespace Lucene.Net.Index
 
     /// <summary>
     /// Controls how much information is stored in the postings lists.
+    /// <para/>
     /// @lucene.experimental
     /// </summary>
     public enum IndexOptions // LUCENENET specific: de-nested from FieldInfo to prevent naming collisions

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/e6c2b88a/src/Lucene.Net/Index/FieldInfos.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Index/FieldInfos.cs b/src/Lucene.Net/Index/FieldInfos.cs
index 20de5bc..072f67b 100644
--- a/src/Lucene.Net/Index/FieldInfos.cs
+++ b/src/Lucene.Net/Index/FieldInfos.cs
@@ -24,8 +24,9 @@ namespace Lucene.Net.Index
      */
 
     /// <summary>
-    /// Collection of <seealso cref="FieldInfo"/>s (accessible by number or by name).
-    ///  @lucene.experimental
+    /// Collection of <see cref="Index.FieldInfo"/>s (accessible by number or by name).
+    /// <para/>
+    /// @lucene.experimental
     /// </summary>
 #if FEATURE_SERIALIZABLE
     [Serializable]
@@ -45,7 +46,7 @@ namespace Lucene.Net.Index
         private readonly ICollection<FieldInfo> values; // for an unmodifiable iterator
 
         /// <summary>
-        /// Constructs a new FieldInfos from an array of FieldInfo objects
+        /// Constructs a new <see cref="FieldInfos"/> from an array of <see cref="Index.FieldInfo"/> objects
         /// </summary>
         public FieldInfos(FieldInfo[] infos)
         {
@@ -100,49 +101,49 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Returns true if any fields have freqs </summary>
+        /// Returns <c>true</c> if any fields have freqs </summary>
         public virtual bool HasFreq
         {
             get { return hasFreq; }
         }
 
         /// <summary>
-        /// Returns true if any fields have positions </summary>
+        /// Returns <c>true</c> if any fields have positions </summary>
         public virtual bool HasProx
         {
             get { return hasProx; }
         }
 
         /// <summary>
-        /// Returns true if any fields have payloads </summary>
+        /// Returns <c>true</c> if any fields have payloads </summary>
         public virtual bool HasPayloads
         {
             get { return hasPayloads; }
         }
 
         /// <summary>
-        /// Returns true if any fields have offsets </summary>
+        /// Returns <c>true</c> if any fields have offsets </summary>
         public virtual bool HasOffsets
         {
             get { return hasOffsets; }
         }
 
         /// <summary>
-        /// Returns true if any fields have vectors </summary>
+        /// Returns <c>true</c> if any fields have vectors </summary>
         public virtual bool HasVectors
         {
             get { return hasVectors; }
         }
 
         /// <summary>
-        /// Returns true if any fields have norms </summary>
+        /// Returns <c>true</c> if any fields have norms </summary>
         public virtual bool HasNorms
         {
             get { return hasNorms; }
         }
 
         /// <summary>
-        /// Returns true if any fields have DocValues </summary>
+        /// Returns <c>true</c> if any fields have <see cref="DocValues"/> </summary>
         public virtual bool HasDocValues
         {
             get { return hasDocValues; }
@@ -150,6 +151,7 @@ namespace Lucene.Net.Index
 
         /// <summary>
         /// Returns the number of fields.
+        /// <para/>
         /// NOTE: This was size() in Lucene.
         /// </summary>
         public virtual int Count
@@ -177,8 +179,8 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Return the fieldinfo object referenced by the field name </summary>
-        /// <returns> the FieldInfo object or null when the given fieldName
+        /// Return the <see cref="Index.FieldInfo"/> object referenced by the <paramref name="fieldName"/> </summary>
+        /// <returns> the <see cref="Index.FieldInfo"/> object or <c>null</c> when the given <paramref name="fieldName"/>
         /// doesn't exist. </returns>
         public virtual FieldInfo FieldInfo(string fieldName)
         {
@@ -188,11 +190,11 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Return the fieldinfo object referenced by the fieldNumber. </summary>
+        /// Return the <see cref="Index.FieldInfo"/> object referenced by the <paramref name="fieldNumber"/>. </summary>
         /// <param name="fieldNumber"> field's number. </param>
-        /// <returns> the FieldInfo object or null when the given fieldNumber
+        /// <returns> the <see cref="Index.FieldInfo"/> object or null when the given <paramref name="fieldNumber"/>
         /// doesn't exist. </returns>
-        /// <exception cref="IllegalArgumentException"> if fieldNumber is negative </exception>
+        /// <exception cref="ArgumentException"> if <paramref name="fieldNumber"/> is negative </exception>
         public virtual FieldInfo FieldInfo(int fieldNumber)
         {
             if (fieldNumber < 0)
@@ -207,7 +209,7 @@ namespace Lucene.Net.Index
 #if FEATURE_SERIALIZABLE
         [Serializable]
 #endif
-        public sealed class FieldNumbers
+        internal sealed class FieldNumbers
         {
             private readonly IDictionary<int?, string> numberToName;
             private readonly IDictionary<string, int?> nameToNumber;
@@ -301,8 +303,8 @@ namespace Lucene.Net.Index
             }
 
             /// <summary>
-            /// Returns true if the {@code fieldName} exists in the map and is of the
-            /// same {@code dvType}.
+            /// Returns <c>true</c> if the <paramref name="fieldName"/> exists in the map and is of the
+            /// same <paramref name="dvType"/>.
             /// </summary>
             internal bool Contains(string fieldName, DocValuesType dvType)
             {
@@ -357,7 +359,7 @@ namespace Lucene.Net.Index
             }
 
             /// <summary>
-            /// Creates a new instance with the given <seealso cref="FieldNumbers"/>.
+            /// Creates a new instance with the given <see cref="FieldNumbers"/>.
             /// </summary>
             internal Builder(FieldNumbers globalFieldNumbers)
             {
@@ -375,10 +377,10 @@ namespace Lucene.Net.Index
 
             /// <summary>
             /// NOTE: this method does not carry over termVector
-            ///  booleans nor docValuesType; the indexer chain
-            ///  (TermVectorsConsumerPerField, DocFieldProcessor) must
-            ///  set these fields when they succeed in consuming
-            ///  the document
+            /// booleans nor docValuesType; the indexer chain
+            /// (TermVectorsConsumerPerField, DocFieldProcessor) must
+            /// set these fields when they succeed in consuming
+            /// the document
             /// </summary>
             public FieldInfo AddOrUpdate(string name, IIndexableFieldType fieldType)
             {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/e6c2b88a/src/Lucene.Net/Index/FieldInvertState.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Index/FieldInvertState.cs b/src/Lucene.Net/Index/FieldInvertState.cs
index a83d0f8..67a8825 100644
--- a/src/Lucene.Net/Index/FieldInvertState.cs
+++ b/src/Lucene.Net/Index/FieldInvertState.cs
@@ -23,10 +23,10 @@ namespace Lucene.Net.Index
     using AttributeSource = Lucene.Net.Util.AttributeSource;
 
     /// <summary>
-    /// this class tracks the number and position / offset parameters of terms
+    /// This class tracks the number and position / offset parameters of terms
     /// being added to the index. The information collected in this class is
     /// also used to calculate the normalization factor for a field.
-    ///
+    /// <para/>
     /// @lucene.experimental
     /// </summary>
 #if FEATURE_SERIALIZABLE
@@ -46,8 +46,8 @@ namespace Lucene.Net.Index
         private AttributeSource attributeSource;
 
         /// <summary>
-        /// Creates {code FieldInvertState} for the specified
-        ///  field name.
+        /// Creates <see cref="FieldInvertState"/> for the specified
+        /// field name.
         /// </summary>
         public FieldInvertState(string name)
         {
@@ -55,8 +55,8 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Creates {code FieldInvertState} for the specified
-        ///  field name and values for all fields.
+        /// Creates <see cref="FieldInvertState"/> for the specified
+        /// field name and values for all fields.
         /// </summary>
         public FieldInvertState(string name, int position, int length, int numOverlap, int offset, float boost)
         {
@@ -84,7 +84,7 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Get the last processed term position. </summary>
+        /// Gets the last processed term position. </summary>
         /// <returns> the position </returns>
         public int Position
         {
@@ -99,7 +99,7 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Get total number of terms in this field. </summary>
+        /// Gets or Sets total number of terms in this field. </summary>
         /// <returns> the length </returns>
         public int Length
         {
@@ -114,7 +114,7 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Get the number of terms with <code>positionIncrement == 0</code>. </summary>
+        /// Gets or Sets the number of terms with <c>positionIncrement == 0</c>. </summary>
         /// <returns> the numOverlap </returns>
         public int NumOverlap
         {
@@ -129,7 +129,7 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Get end offset of the last processed term. </summary>
+        /// Gets end offset of the last processed term. </summary>
         /// <returns> the offset </returns>
         public int Offset
         {
@@ -144,7 +144,7 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Get boost value. this is the cumulative product of
+        /// Gets or Sets boost value. This is the cumulative product of
         /// document boost and field boost for all field instances
         /// sharing the same field name. </summary>
         /// <returns> the boost </returns>
@@ -178,7 +178,7 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Return the number of unique terms encountered in this field.
+        /// Gets the number of unique terms encountered in this field.
         /// </summary>
         public int UniqueTermCount
         {
@@ -193,9 +193,9 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Returns the <seealso cref="AttributeSource"/> from the {@link
-        ///  TokenStream} that provided the indexed tokens for this
-        ///  field.
+        /// Gets the <see cref="Util.AttributeSource"/> from the
+        /// <see cref="Analysis.TokenStream"/> that provided the indexed tokens for this
+        /// field.
         /// </summary>
         public AttributeSource AttributeSource
         {
@@ -210,7 +210,7 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Return the field's name
+        /// Gets the field's name
         /// </summary>
         public string Name
         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/e6c2b88a/src/Lucene.Net/Index/Fields.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Index/Fields.cs b/src/Lucene.Net/Index/Fields.cs
index 7d11286..1d54990 100644
--- a/src/Lucene.Net/Index/Fields.cs
+++ b/src/Lucene.Net/Index/Fields.cs
@@ -23,7 +23,8 @@ namespace Lucene.Net.Index
 
     /// <summary>
     /// Flex API for access to fields and terms
-    ///  @lucene.experimental
+    /// <para/>
+    /// @lucene.experimental
     /// </summary>
 #if FEATURE_SERIALIZABLE
     [Serializable]
@@ -32,15 +33,15 @@ namespace Lucene.Net.Index
     {
         /// <summary>
         /// Sole constructor. (For invocation by subclass
-        ///  constructors, typically implicit.)
+        /// constructors, typically implicit.)
         /// </summary>
         protected Fields()
         {
         }
 
         /// <summary>
-        /// Returns an iterator that will step through all fields
-        ///  names.  this will not return null.
+        /// Returns an enumerator that will step through all field
+        /// names.  This will not return <c>null</c>.
         /// </summary>
         public abstract IEnumerator<string> GetEnumerator();
 
@@ -50,8 +51,8 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Get the <see cref="Terms"/> for this field.  this will return
-        /// null if the field does not exist.
+        /// Get the <see cref="Terms"/> for this field.  This will return
+        /// <c>null</c> if the field does not exist.
         /// </summary>
         public abstract Terms GetTerms(string field);
 
@@ -59,21 +60,19 @@ namespace Lucene.Net.Index
         /// Gets the number of fields or -1 if the number of
         /// distinct field names is unknown. If &gt;= 0,
         /// <see cref="GetEnumerator"/> will return as many field names.
+        /// <para/>
         /// NOTE: This was size() in Lucene.
         /// </summary>
         public abstract int Count { get; }
 
         /// <summary>
         /// Returns the number of terms for all fields, or -1 if this
-        ///  measure isn't stored by the codec. Note that, just like
-        ///  other term measures, this measure does not take deleted
-        ///  documents into account. </summary>
-        ///  @deprecated iterate fields and add their Count instead.
-        ///   this method is only provided as a transition mechanism
-        ///   to access this statistic for 3.x indexes, which do not
-        ///   have this statistic per-field.
-        ///  <seealso cref="Index.Terms.Count"></seealso>
-        [Obsolete("iterate fields and add their Count instead.")]
+        /// measure isn't stored by the codec. Note that, just like
+        /// other term measures, this measure does not take deleted
+        /// documents into account. 
+        /// </summary>
+        /// <seealso cref="Index.Terms.Count"></seealso>
+        [Obsolete("Iterate fields and add their Count instead. This method is only provided as a transition mechanism to access this statistic for 3.x indexes, which do not have this statistic per-field.")]
         public virtual long UniqueTermCount
         {
             get
@@ -98,7 +97,7 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Zero-length {@code Fields} array.
+        /// Zero-length <see cref="Fields"/> array.
         /// </summary>
         public static readonly Fields[] EMPTY_ARRAY = new Fields[0];
     }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/e6c2b88a/src/Lucene.Net/Index/FilterAtomicReader.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Index/FilterAtomicReader.cs b/src/Lucene.Net/Index/FilterAtomicReader.cs
index 43d4272..9481437 100644
--- a/src/Lucene.Net/Index/FilterAtomicReader.cs
+++ b/src/Lucene.Net/Index/FilterAtomicReader.cs
@@ -26,22 +26,22 @@ namespace Lucene.Net.Index
     using BytesRef = Lucene.Net.Util.BytesRef;
 
     /// <summary>
-    ///  A <code>FilterAtomicReader</code> contains another AtomicReader, which it
+    /// A <see cref="FilterAtomicReader"/> contains another <see cref="AtomicReader"/>, which it
     /// uses as its basic source of data, possibly transforming the data along the
     /// way or providing additional functionality. The class
-    /// <code>FilterAtomicReader</code> itself simply implements all abstract methods
-    /// of <code>IndexReader</code> with versions that pass all requests to the
-    /// contained index reader. Subclasses of <code>FilterAtomicReader</code> may
+    /// <see cref="FilterAtomicReader"/> itself simply implements all abstract methods
+    /// of <see cref="IndexReader"/> with versions that pass all requests to the
+    /// contained index reader. Subclasses of <see cref="FilterAtomicReader"/> may
     /// further override some of these methods and may also provide additional
     /// methods and fields.
-    /// <p><b>NOTE</b>: If you override <seealso cref="#getLiveDocs()"/>, you will likely need
-    /// to override <seealso cref="#numDocs()"/> as well and vice-versa.
-    /// <p><b>NOTE</b>: If this <seealso cref="FilterAtomicReader"/> does not change the
+    /// <para/><b>NOTE</b>: If you override <see cref="LiveDocs"/>, you will likely need
+    /// to override <see cref="NumDocs"/> as well and vice-versa.
+    /// <para/><b>NOTE</b>: If this <see cref="FilterAtomicReader"/> does not change the
     /// content the contained reader, you could consider overriding
-    /// <seealso cref="#getCoreCacheKey()"/> so that <seealso cref="IFieldCache"/> and
-    /// <seealso cref="CachingWrapperFilter"/> share the same entries for this atomic reader
-    /// and the wrapped one. <seealso cref="#getCombinedCoreAndDeletesKey()"/> could be
-    /// overridden as well if the <seealso cref="#getLiveDocs() live docs"/> are not changed
+    /// <see cref="IndexReader.CoreCacheKey"/> so that <see cref="Search.IFieldCache"/> and
+    /// <see cref="Search.CachingWrapperFilter"/> share the same entries for this atomic reader
+    /// and the wrapped one. <see cref="IndexReader.CombinedCoreAndDeletesKey"/> could be
+    /// overridden as well if the <see cref="LiveDocs"/> are not changed
     /// either.
     /// </summary>
 #if FEATURE_SERIALIZABLE
@@ -50,8 +50,8 @@ namespace Lucene.Net.Index
     public class FilterAtomicReader : AtomicReader
     {
         /// <summary>
-        /// Get the wrapped instance by <code>reader</code> as long as this reader is
-        ///  an intance of <seealso cref="FilterAtomicReader"/>.
+        /// Get the wrapped instance by <paramref name="reader"/> as long as this reader is
+        /// an intance of <see cref="FilterAtomicReader"/>.
         /// </summary>
         public static AtomicReader Unwrap(AtomicReader reader)
         {
@@ -63,8 +63,8 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Base class for filtering <seealso cref="Fields"/>
-        ///  implementations.
+        /// Base class for filtering <see cref="Index.Fields"/>
+        /// implementations.
         /// </summary>
 #if FEATURE_SERIALIZABLE
         [Serializable]
@@ -72,12 +72,12 @@ namespace Lucene.Net.Index
         public class FilterFields : Fields
         {
             /// <summary>
-            /// The underlying Fields instance. </summary>
+            /// The underlying <see cref="Index.Fields"/> instance. </summary>
             protected readonly Fields m_input;
 
             /// <summary>
-            /// Creates a new FilterFields. </summary>
-            /// <param name="input"> the underlying Fields instance. </param>
+            /// Creates a new <see cref="FilterFields"/>. </summary>
+            /// <param name="input"> the underlying <see cref="Index.Fields"/> instance. </param>
             public FilterFields(Fields input)
             {
                 this.m_input = input;
@@ -100,10 +100,10 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Base class for filtering <seealso cref="Terms"/> implementations.
-        /// <p><b>NOTE</b>: If the order of terms and documents is not changed, and if
+        /// Base class for filtering <see cref="Terms"/> implementations.
+        /// <para/><b>NOTE</b>: If the order of terms and documents is not changed, and if
         /// these terms are going to be intersected with automata, you could consider
-        /// overriding <seealso cref="#intersect"/> for better performance.
+        /// overriding <see cref="Terms.Intersect"/> for better performance.
         /// </summary>
 #if FEATURE_SERIALIZABLE
         [Serializable]
@@ -111,12 +111,12 @@ namespace Lucene.Net.Index
         public class FilterTerms : Terms
         {
             /// <summary>
-            /// The underlying Terms instance. </summary>
+            /// The underlying <see cref="Terms"/> instance. </summary>
             protected readonly Terms m_input;
 
             /// <summary>
-            /// Creates a new FilterTerms </summary>
-            /// <param name="input"> the underlying Terms instance. </param>
+            /// Creates a new <see cref="FilterTerms"/> </summary>
+            /// <param name="input"> the underlying <see cref="Terms"/> instance. </param>
             public FilterTerms(Terms input)
             {
                 this.m_input = input;
@@ -186,19 +186,19 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Base class for filtering <seealso cref="TermsEnum"/> implementations. </summary>
+        /// Base class for filtering <see cref="TermsEnum"/> implementations. </summary>
 #if FEATURE_SERIALIZABLE
         [Serializable]
 #endif
         public class FilterTermsEnum : TermsEnum
         {
             /// <summary>
-            /// The underlying TermsEnum instance. </summary>
+            /// The underlying <see cref="TermsEnum"/> instance. </summary>
             protected internal readonly TermsEnum m_input;
 
             /// <summary>
-            /// Creates a new FilterTermsEnum </summary>
-            /// <param name="input"> the underlying TermsEnum instance. </param>
+            /// Creates a new <see cref="FilterTermsEnum"/> </summary>
+            /// <param name="input"> the underlying <see cref="TermsEnum"/> instance. </param>
             public FilterTermsEnum(TermsEnum input)
             {
                 this.m_input = input;
@@ -264,20 +264,20 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Base class for filtering <seealso cref="DocsEnum"/> implementations. </summary>
+        /// Base class for filtering <see cref="DocsEnum"/> implementations. </summary>
 #if FEATURE_SERIALIZABLE
         [Serializable]
 #endif
         public class FilterDocsEnum : DocsEnum
         {
             /// <summary>
-            /// The underlying DocsEnum instance.
+            /// The underlying <see cref="DocsEnum"/> instance.
             /// </summary>
             protected internal DocsEnum m_input;
 
             /// <summary>
-            /// Create a new FilterDocsEnum </summary>
-            /// <param name="input"> the underlying DocsEnum instance. </param>
+            /// Create a new <see cref="FilterDocsEnum"/> </summary>
+            /// <param name="input"> the underlying <see cref="DocsEnum"/> instance. </param>
             public FilterDocsEnum(DocsEnum input)
             {
                 this.m_input = input;
@@ -315,19 +315,19 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Base class for filtering <seealso cref="DocsAndPositionsEnum"/> implementations. </summary>
+        /// Base class for filtering <see cref="DocsAndPositionsEnum"/> implementations. </summary>
 #if FEATURE_SERIALIZABLE
         [Serializable]
 #endif
         public class FilterDocsAndPositionsEnum : DocsAndPositionsEnum
         {
             /// <summary>
-            /// The underlying DocsAndPositionsEnum instance. </summary>
+            /// The underlying <see cref="DocsAndPositionsEnum"/> instance. </summary>
             protected internal readonly DocsAndPositionsEnum m_input;
 
             /// <summary>
-            /// Create a new FilterDocsAndPositionsEnum </summary>
-            /// <param name="input"> the underlying DocsAndPositionsEnum instance. </param>
+            /// Create a new <see cref="FilterDocsAndPositionsEnum"/> </summary>
+            /// <param name="input"> the underlying <see cref="DocsAndPositionsEnum"/> instance. </param>
             public FilterDocsAndPositionsEnum(DocsAndPositionsEnum input)
             {
                 this.m_input = input;
@@ -385,13 +385,15 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// The underlying AtomicReader. </summary>
+        /// The underlying <see cref="AtomicReader"/>. </summary>
         protected readonly AtomicReader m_input;
 
         /// <summary>
-        /// <p>Construct a FilterAtomicReader based on the specified base reader.
-        /// <p>Note that base reader is closed if this FilterAtomicReader is closed.</p> </summary>
-        /// <param name="in"> specified base reader. </param>
+        /// Construct a <see cref="FilterAtomicReader"/> based on the specified base reader.
+        /// <para/>
+        /// Note that base reader is closed if this <see cref="FilterAtomicReader"/> is closed.
+        /// </summary>
+        /// <param name="input"> specified base reader. </param>
         public FilterAtomicReader(AtomicReader input)
             : base()
         {
@@ -426,10 +428,8 @@ namespace Lucene.Net.Index
         {
             get
             {
-                {
-                    // Don't call ensureOpen() here (it could affect performance)
-                    return m_input.NumDocs;
-                }
+                // Don't call ensureOpen() here (it could affect performance)
+                return m_input.NumDocs;
             }
         }
 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/e6c2b88a/src/Lucene.Net/Index/FilterDirectoryReader.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Index/FilterDirectoryReader.cs b/src/Lucene.Net/Index/FilterDirectoryReader.cs
index c9de639..85af88d 100644
--- a/src/Lucene.Net/Index/FilterDirectoryReader.cs
+++ b/src/Lucene.Net/Index/FilterDirectoryReader.cs
@@ -22,14 +22,14 @@ namespace Lucene.Net.Index
      */
 
     /// <summary>
-    /// A FilterDirectoryReader wraps another DirectoryReader, allowing implementations
+    /// A <see cref="FilterDirectoryReader"/> wraps another <see cref="DirectoryReader"/>, allowing implementations
     /// to transform or extend it.
-    ///
-    /// Subclasses should implement doWrapDirectoryReader to return an instance of the
+    /// <para/>
+    /// Subclasses should implement <see cref="DoWrapDirectoryReader(DirectoryReader)"/> to return an instance of the
     /// subclass.
-    ///
-    /// If the subclass wants to wrap the DirectoryReader's subreaders, it should also
-    /// implement a SubReaderWrapper subclass, and pass an instance to its super
+    /// <para/>
+    /// If the subclass wants to wrap the <see cref="DirectoryReader"/>'s subreaders, it should also
+    /// implement a <see cref="SubReaderWrapper"/> subclass, and pass an instance to its base
     /// constructor.
     /// </summary>
 #if FEATURE_SERIALIZABLE
@@ -38,10 +38,10 @@ namespace Lucene.Net.Index
     public abstract class FilterDirectoryReader : DirectoryReader
     {
         /// <summary>
-        /// Factory class passed to FilterDirectoryReader constructor that allows
-        /// subclasses to wrap the filtered DirectoryReader's subreaders.  You
-        /// can use this to, e.g., wrap the subreaders with specialised
-        /// FilterAtomicReader implementations.
+        /// Factory class passed to <see cref="FilterDirectoryReader"/> constructor that allows
+        /// subclasses to wrap the filtered <see cref="DirectoryReader"/>'s subreaders.  You
+        /// can use this to, e.g., wrap the subreaders with specialized
+        /// <see cref="FilterAtomicReader"/> implementations.
         /// </summary>
 #if FEATURE_SERIALIZABLE
         [Serializable]
@@ -65,15 +65,15 @@ namespace Lucene.Net.Index
             }
 
             /// <summary>
-            /// Wrap one of the parent DirectoryReader's subreaders </summary>
+            /// Wrap one of the parent <see cref="DirectoryReader"/>'s subreaders </summary>
             /// <param name="reader"> the subreader to wrap </param>
-            /// <returns> a wrapped/filtered AtomicReader </returns>
+            /// <returns> a wrapped/filtered <see cref="AtomicReader"/> </returns>
             public abstract AtomicReader Wrap(AtomicReader reader);
         }
 
         /// <summary>
-        /// A no-op SubReaderWrapper that simply returns the parent
-        /// DirectoryReader's original subreaders.
+        /// A no-op <see cref="SubReaderWrapper"/> that simply returns the parent
+        /// <see cref="DirectoryReader"/>'s original subreaders.
         /// </summary>
 #if FEATURE_SERIALIZABLE
         [Serializable]
@@ -93,22 +93,22 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// The filtered DirectoryReader </summary>
+        /// The filtered <see cref="DirectoryReader"/> </summary>
         protected readonly DirectoryReader m_input;
 
         /// <summary>
-        /// Create a new FilterDirectoryReader that filters a passed in DirectoryReader. </summary>
-        /// <param name="input"> the DirectoryReader to filter </param>
+        /// Create a new <see cref="FilterDirectoryReader"/> that filters a passed in <see cref="DirectoryReader"/>. </summary>
+        /// <param name="input"> the <see cref="DirectoryReader"/> to filter </param>
         public FilterDirectoryReader(DirectoryReader input)
             : this(input, new StandardReaderWrapper())
         {
         }
 
         /// <summary>
-        /// Create a new FilterDirectoryReader that filters a passed in DirectoryReader,
-        /// using the supplied SubReaderWrapper to wrap its subreader. </summary>
-        /// <param name="input"> the DirectoryReader to filter </param>
-        /// <param name="wrapper"> the SubReaderWrapper to use to wrap subreaders </param>
+        /// Create a new <see cref="FilterDirectoryReader"/> that filters a passed in <see cref="DirectoryReader"/>,
+        /// using the supplied <see cref="SubReaderWrapper"/> to wrap its subreader. </summary>
+        /// <param name="input"> the <see cref="DirectoryReader"/> to filter </param>
+        /// <param name="wrapper"> the <see cref="SubReaderWrapper"/> to use to wrap subreaders </param>
         public FilterDirectoryReader(DirectoryReader input, SubReaderWrapper wrapper)
             : base(input.Directory, wrapper.Wrap(input.GetSequentialSubReaders().OfType<AtomicReader>().ToList()))
         {
@@ -116,13 +116,13 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Called by the doOpenIfChanged() methods to return a new wrapped DirectoryReader.
-        ///
-        /// Implementations should just return an instantiation of themselves, wrapping the
-        /// passed in DirectoryReader.
+        /// Called by the <see cref="DoOpenIfChanged()"/> methods to return a new wrapped <see cref="DirectoryReader"/>.
+        /// <para/>
+        /// Implementations should just return an instance of themselves, wrapping the
+        /// passed in <see cref="DirectoryReader"/>.
         /// </summary>
-        /// <param name="input"> the DirectoryReader to wrap </param>
-        /// <returns> the wrapped DirectoryReader </returns>
+        /// <param name="input"> the <see cref="DirectoryReader"/> to wrap </param>
+        /// <returns> the wrapped <see cref="DirectoryReader"/> </returns>
         protected abstract DirectoryReader DoWrapDirectoryReader(DirectoryReader input);
 
         private DirectoryReader WrapDirectoryReader(DirectoryReader input)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/e6c2b88a/src/Lucene.Net/Index/FilteredTermsEnum.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Index/FilteredTermsEnum.cs b/src/Lucene.Net/Index/FilteredTermsEnum.cs
index 67c2651..a5dda64 100644
--- a/src/Lucene.Net/Index/FilteredTermsEnum.cs
+++ b/src/Lucene.Net/Index/FilteredTermsEnum.cs
@@ -27,13 +27,13 @@ namespace Lucene.Net.Index
 
     /// <summary>
     /// Abstract class for enumerating a subset of all terms.
-    ///
-    /// <p>Term enumerations are always ordered by
-    /// <seealso cref="#getComparer"/>.  Each term in the enumeration is
-    /// greater than all that precede it.</p>
-    /// <p><em>Please note:</em> Consumers of this enum cannot
-    /// call {@code seek()}, it is forward only; it throws
-    /// <seealso cref="UnsupportedOperationException"/> when a seeking method
+    /// <para/>
+    /// Term enumerations are always ordered by
+    /// <see cref="Comparer"/>.  Each term in the enumeration is
+    /// greater than all that precede it.
+    /// <para/><c>Please note:</c> Consumers of this enumeration cannot
+    /// call <c>Seek()</c>, it is forward only; it throws
+    /// <see cref="NotSupportedException"/> when a seeking method
     /// is called.
     /// </summary>
 #if FEATURE_SERIALIZABLE
@@ -49,9 +49,9 @@ namespace Lucene.Net.Index
 
         /// <summary>
         /// Return value, if term should be accepted or the iteration should
-        /// {@code END}. The {@code *_SEEK} values denote, that after handling the current term
-        /// the enum should call <seealso cref="#nextSeekTerm"/> and step forward. </summary>
-        /// <seealso cref= #accept(BytesRef) </seealso>
+        /// <see cref="END"/>. The <c>*_SEEK</c> values denote, that after handling the current term
+        /// the enum should call <see cref="NextSeekTerm(BytesRef)"/> and step forward. </summary>
+        /// <seealso cref="Accept(BytesRef)"/>
         protected internal enum AcceptStatus
         {
             /// <summary>
@@ -59,7 +59,7 @@ namespace Lucene.Net.Index
             YES,
 
             /// <summary>
-            /// Accept the term and advance (<seealso cref="FilteredTermsEnum#nextSeekTerm(BytesRef)"/>)
+            /// Accept the term and advance (<see cref="FilteredTermsEnum.NextSeekTerm(BytesRef)"/>)
             /// to the next term.
             /// </summary>
             YES_AND_SEEK,
@@ -69,7 +69,7 @@ namespace Lucene.Net.Index
             NO,
 
             /// <summary>
-            /// Reject the term and advance (<seealso cref="FilteredTermsEnum#nextSeekTerm(BytesRef)"/>)
+            /// Reject the term and advance (<see cref="FilteredTermsEnum.NextSeekTerm(BytesRef)"/>)
             /// to the next term.
             /// </summary>
             NO_AND_SEEK,
@@ -86,7 +86,7 @@ namespace Lucene.Net.Index
         protected abstract AcceptStatus Accept(BytesRef term);
 
         /// <summary>
-        /// Creates a filtered <seealso cref="TermsEnum"/> on a terms enum. </summary>
+        /// Creates a filtered <see cref="TermsEnum"/> on a terms enum. </summary>
         /// <param name="tenum"> the terms enumeration to filter. </param>
         public FilteredTermsEnum(TermsEnum tenum)
             : this(tenum, true)
@@ -94,8 +94,9 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Creates a filtered <seealso cref="TermsEnum"/> on a terms enum. </summary>
+        /// Creates a filtered <see cref="TermsEnum"/> on a terms enum. </summary>
         /// <param name="tenum"> the terms enumeration to filter. </param>
+        /// <param name="startWithSeek"> start with seek </param>
         public FilteredTermsEnum(TermsEnum tenum, bool startWithSeek)
         {
             Debug.Assert(tenum != null);
@@ -104,13 +105,13 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Use this method to set the initial <seealso cref="BytesRef"/>
-        /// to seek before iterating. this is a convenience method for
-        /// subclasses that do not override <seealso cref="#nextSeekTerm"/>.
-        /// If the initial seek term is {@code null} (default),
+        /// Use this method to set the initial <see cref="BytesRef"/>
+        /// to seek before iterating. This is a convenience method for
+        /// subclasses that do not override <see cref="NextSeekTerm(BytesRef)"/>.
+        /// If the initial seek term is <c>null</c> (default),
         /// the enum is empty.
-        /// <P>You can only use this method, if you keep the default
-        /// implementation of <seealso cref="#nextSeekTerm"/>.
+        /// <para/>You can only use this method, if you keep the default
+        /// implementation of <see cref="NextSeekTerm(BytesRef)"/>.
         /// </summary>
         protected void SetInitialSeekTerm(BytesRef term)
         {
@@ -118,20 +119,21 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// On the first call to <seealso cref="#next"/> or if <seealso cref="#accept"/> returns
-        /// <seealso cref="AcceptStatus#YES_AND_SEEK"/> or <seealso cref="AcceptStatus#NO_AND_SEEK"/>,
-        /// this method will be called to eventually seek the underlying TermsEnum
+        /// On the first call to <see cref="Next()"/> or if <see cref="Accept(BytesRef)"/> returns
+        /// <see cref="AcceptStatus.YES_AND_SEEK"/> or <see cref="AcceptStatus.NO_AND_SEEK"/>,
+        /// this method will be called to eventually seek the underlying <see cref="TermsEnum"/>
         /// to a new position.
-        /// On the first call, {@code currentTerm} will be {@code null}, later
+        /// On the first call, <paramref name="currentTerm"/> will be <c>null</c>, later
         /// calls will provide the term the underlying enum is positioned at.
-        /// this method returns per default only one time the initial seek term
-        /// and then {@code null}, so no repositioning is ever done.
-        /// <p>Override this method, if you want a more sophisticated TermsEnum,
+        /// This method returns per default only one time the initial seek term
+        /// and then <c>null</c>, so no repositioning is ever done.
+        /// <para/>
+        /// Override this method, if you want a more sophisticated <see cref="TermsEnum"/>,
         /// that repositions the iterator during enumeration.
-        /// If this method always returns {@code null} the enum is empty.
-        /// <p><em>Please note:</em> this method should always provide a greater term
-        /// than the last enumerated term, else the behaviour of this enum
-        /// violates the contract for TermsEnums.
+        /// If this method always returns <c>null</c> the enum is empty.
+        /// <para/><c>Please note:</c> this method should always provide a greater term
+        /// than the last enumerated term, else the behavior of this enum
+        /// violates the contract for <see cref="TermsEnum"/>s.
         /// </summary>
         protected virtual BytesRef NextSeekTerm(BytesRef currentTerm)
         {
@@ -141,8 +143,8 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Returns the related attributes, the returned <seealso cref="AttributeSource"/>
-        /// is shared with the delegate {@code TermsEnum}.
+        /// Returns the related attributes, the returned <see cref="AttributeSource"/>
+        /// is shared with the delegate <see cref="TermsEnum"/>.
         /// </summary>
         public override AttributeSource Attributes
         {
@@ -174,7 +176,7 @@ namespace Lucene.Net.Index
 
         /// <summary>
         /// this enum does not support seeking! </summary>
-        /// <exception cref="UnsupportedOperationException"> In general, subclasses do not
+        /// <exception cref="NotSupportedException"> In general, subclasses do not
         ///         support seeking. </exception>
         public override bool SeekExact(BytesRef term)
         {
@@ -183,7 +185,7 @@ namespace Lucene.Net.Index
 
         /// <summary>
         /// this enum does not support seeking! </summary>
-        /// <exception cref="UnsupportedOperationException"> In general, subclasses do not
+        /// <exception cref="NotSupportedException"> In general, subclasses do not
         ///         support seeking. </exception>
         public override SeekStatus SeekCeil(BytesRef term)
         {
@@ -192,7 +194,7 @@ namespace Lucene.Net.Index
 
         /// <summary>
         /// this enum does not support seeking! </summary>
-        /// <exception cref="UnsupportedOperationException"> In general, subclasses do not
+        /// <exception cref="NotSupportedException"> In general, subclasses do not
         ///         support seeking. </exception>
         public override void SeekExact(long ord)
         {
@@ -216,7 +218,7 @@ namespace Lucene.Net.Index
 
         /// <summary>
         /// this enum does not support seeking! </summary>
-        /// <exception cref="UnsupportedOperationException"> In general, subclasses do not
+        /// <exception cref="NotSupportedException"> In general, subclasses do not
         ///         support seeking. </exception>
         public override void SeekExact(BytesRef term, TermState state)
         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/e6c2b88a/src/Lucene.Net/Index/FlushByRamOrCountsPolicy.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Index/FlushByRamOrCountsPolicy.cs b/src/Lucene.Net/Index/FlushByRamOrCountsPolicy.cs
index e3b8c14..5ed2c7b 100644
--- a/src/Lucene.Net/Index/FlushByRamOrCountsPolicy.cs
+++ b/src/Lucene.Net/Index/FlushByRamOrCountsPolicy.cs
@@ -22,40 +22,43 @@ namespace Lucene.Net.Index
     using ThreadState = Lucene.Net.Index.DocumentsWriterPerThreadPool.ThreadState;
 
     /// <summary>
-    /// Default <seealso cref="FlushPolicy"/> implementation that flushes new segments based on
-    /// RAM used and document count depending on the IndexWriter's
-    /// <seealso cref="IndexWriterConfig"/>. It also applies pending deletes based on the
+    /// Default <see cref="FlushPolicy"/> implementation that flushes new segments based on
+    /// RAM used and document count depending on the <see cref="IndexWriter"/>'s
+    /// <see cref="IndexWriterConfig"/>. It also applies pending deletes based on the
     /// number of buffered delete terms.
     ///
-    /// <ul>
-    /// <li>
-    /// <seealso cref="#onDelete(DocumentsWriterFlushControl, DocumentsWriterPerThreadPool.ThreadState)"/>
-    /// - applies pending delete operations based on the global number of buffered
-    /// delete terms iff <seealso cref="IndexWriterConfig#getMaxBufferedDeleteTerms()"/> is
-    /// enabled</li>
-    /// <li>
-    /// <seealso cref="#onInsert(DocumentsWriterFlushControl, DocumentsWriterPerThreadPool.ThreadState)"/>
-    /// - flushes either on the number of documents per
-    /// <seealso cref="DocumentsWriterPerThread"/> (
-    /// <seealso cref="DocumentsWriterPerThread#getNumDocsInRAM()"/>) or on the global active
-    /// memory consumption in the current indexing session iff
-    /// <seealso cref="IndexWriterConfig#getMaxBufferedDocs()"/> or
-    /// <seealso cref="IndexWriterConfig#getRAMBufferSizeMB()"/> is enabled respectively</li>
-    /// <li>
-    /// <seealso cref="#onUpdate(DocumentsWriterFlushControl, DocumentsWriterPerThreadPool.ThreadState)"/>
-    /// - calls
-    /// <seealso cref="#onInsert(DocumentsWriterFlushControl, DocumentsWriterPerThreadPool.ThreadState)"/>
-    /// and
-    /// <seealso cref="#onDelete(DocumentsWriterFlushControl, DocumentsWriterPerThreadPool.ThreadState)"/>
-    /// in order</li>
-    /// </ul>
-    /// All <seealso cref="IndexWriterConfig"/> settings are used to mark
-    /// <seealso cref="DocumentsWriterPerThread"/> as flush pending during indexing with
+    /// <list type="bullet">
+    ///     <item>
+    ///         <see cref="OnDelete(DocumentsWriterFlushControl, DocumentsWriterPerThreadPool.ThreadState)"/>
+    ///         - applies pending delete operations based on the global number of buffered
+    ///         delete terms iff <see cref="LiveIndexWriterConfig.MaxBufferedDeleteTerms"/> is
+    ///         enabled
+    ///     </item>
+    ///     <item>
+    ///         <see cref="OnInsert(DocumentsWriterFlushControl, DocumentsWriterPerThreadPool.ThreadState)"/>
+    ///         - flushes either on the number of documents per
+    ///         <see cref="DocumentsWriterPerThread"/> (
+    ///         <see cref="DocumentsWriterPerThread.NumDocsInRAM"/>) or on the global active
+    ///         memory consumption in the current indexing session iff
+    ///         <see cref="LiveIndexWriterConfig.MaxBufferedDocs"/> or
+    ///         <see cref="LiveIndexWriterConfig.RAMBufferSizeMB"/> is enabled respectively
+    ///     </item>
+    ///     <item>
+    ///         <see cref="FlushPolicy.OnUpdate(DocumentsWriterFlushControl, DocumentsWriterPerThreadPool.ThreadState)"/>
+    ///         - calls
+    ///         <see cref="OnInsert(DocumentsWriterFlushControl, DocumentsWriterPerThreadPool.ThreadState)"/>
+    ///         and
+    ///         <see cref="OnDelete(DocumentsWriterFlushControl, DocumentsWriterPerThreadPool.ThreadState)"/>
+    ///         in order
+    ///     </item>
+    /// </list>
+    /// All <see cref="IndexWriterConfig"/> settings are used to mark
+    /// <see cref="DocumentsWriterPerThread"/> as flush pending during indexing with
     /// respect to their live updates.
-    /// <p>
-    /// If <seealso cref="IndexWriterConfig#setRAMBufferSizeMB(double)"/> is enabled, the
-    /// largest ram consuming <seealso cref="DocumentsWriterPerThread"/> will be marked as
-    /// pending iff the global active RAM consumption is >= the configured max RAM
+    /// <para/>
+    /// If <see cref="LiveIndexWriterConfig.RAMBufferSizeMB"/> (setter) is enabled, the
+    /// largest ram consuming <see cref="DocumentsWriterPerThread"/> will be marked as
+    /// pending iff the global active RAM consumption is &gt;= the configured max RAM
     /// buffer.
     /// </summary>
 #if FEATURE_SERIALIZABLE
@@ -107,7 +110,7 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Marks the most ram consuming active <seealso cref="DocumentsWriterPerThread"/> flush
+        /// Marks the most ram consuming active <see cref="DocumentsWriterPerThread"/> flush
         /// pending
         /// </summary>
         protected virtual void MarkLargestWriterPending(DocumentsWriterFlushControl control, ThreadState perThreadState, long currentBytesPerThread)
@@ -116,9 +119,9 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Returns <code>true</code> if this <seealso cref="FlushPolicy"/> flushes on
-        /// <seealso cref="IndexWriterConfig#getMaxBufferedDocs()"/>, otherwise
-        /// <code>false</code>.
+        /// Returns <c>true</c> if this <see cref="FlushPolicy"/> flushes on
+        /// <see cref="LiveIndexWriterConfig.MaxBufferedDocs"/>, otherwise
+        /// <c>false</c>.
         /// </summary>
         protected internal virtual bool FlushOnDocCount
         {
@@ -126,9 +129,9 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Returns <code>true</code> if this <seealso cref="FlushPolicy"/> flushes on
-        /// <seealso cref="IndexWriterConfig#getMaxBufferedDeleteTerms()"/>, otherwise
-        /// <code>false</code>.
+        /// Returns <c>true</c> if this <see cref="FlushPolicy"/> flushes on
+        /// <see cref="LiveIndexWriterConfig.MaxBufferedDeleteTerms"/>, otherwise
+        /// <c>false</c>.
         /// </summary>
         protected internal virtual bool FlushOnDeleteTerms
         {
@@ -136,9 +139,9 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Returns <code>true</code> if this <seealso cref="FlushPolicy"/> flushes on
-        /// <seealso cref="IndexWriterConfig#getRAMBufferSizeMB()"/>, otherwise
-        /// <code>false</code>.
+        /// Returns <c>true</c> if this <see cref="FlushPolicy"/> flushes on
+        /// <see cref="LiveIndexWriterConfig.RAMBufferSizeMB"/>, otherwise
+        /// <c>false</c>.
         /// </summary>
         protected internal virtual bool FlushOnRAM
         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/e6c2b88a/src/Lucene.Net/Index/FlushPolicy.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Index/FlushPolicy.cs b/src/Lucene.Net/Index/FlushPolicy.cs
index 3986504..d342b0b 100644
--- a/src/Lucene.Net/Index/FlushPolicy.cs
+++ b/src/Lucene.Net/Index/FlushPolicy.cs
@@ -25,33 +25,33 @@ namespace Lucene.Net.Index
     using ThreadState = Lucene.Net.Index.DocumentsWriterPerThreadPool.ThreadState;
 
     /// <summary>
-    /// <seealso cref="FlushPolicy"/> controls when segments are flushed from a RAM resident
-    /// internal data-structure to the <seealso cref="IndexWriter"/>s <seealso cref="Directory"/>.
-    /// <p>
+    /// <see cref="FlushPolicy"/> controls when segments are flushed from a RAM resident
+    /// internal data-structure to the <see cref="IndexWriter"/>s <see cref="Store.Directory"/>.
+    /// <para/>
     /// Segments are traditionally flushed by:
-    /// <ul>
-    /// <li>RAM consumption - configured via
-    /// <seealso cref="IndexWriterConfig#setRAMBufferSizeMB(double)"/></li>
-    /// <li>Number of RAM resident documents - configured via
-    /// <seealso cref="IndexWriterConfig#setMaxBufferedDocs(int)"/></li>
-    /// </ul>
+    /// <list type="bullet">
+    ///     <item>RAM consumption - configured via
+    ///         <see cref="LiveIndexWriterConfig.RAMBufferSizeMB"/></item>
+    ///     <item>Number of RAM resident documents - configured via
+    ///         <see cref="LiveIndexWriterConfig.MaxBufferedDocs"/></item>
+    /// </list>
     /// The policy also applies pending delete operations (by term and/or query),
     /// given the threshold set in
-    /// <seealso cref="IndexWriterConfig#setMaxBufferedDeleteTerms(int)"/>.
-    /// <p>
-    /// <seealso cref="IndexWriter"/> consults the provided <seealso cref="FlushPolicy"/> to control the
+    /// <see cref="LiveIndexWriterConfig.MaxBufferedDeleteTerms"/>.
+    /// <para/>
+    /// <see cref="IndexWriter"/> consults the provided <seea cref="FlushPolicy"/> to control the
     /// flushing process. The policy is informed for each added or updated document
-    /// as well as for each delete term. Based on the <seealso cref="FlushPolicy"/>, the
-    /// information provided via <seealso cref="ThreadState"/> and
-    /// <seealso cref="DocumentsWriterFlushControl"/>, the <seealso cref="FlushPolicy"/> decides if a
-    /// <seealso cref="DocumentsWriterPerThread"/> needs flushing and mark it as flush-pending
-    /// via <seealso cref="DocumentsWriterFlushControl#setFlushPending"/>, or if deletes need
+    /// as well as for each delete term. Based on the <see cref="FlushPolicy"/>, the
+    /// information provided via <see cref="ThreadState"/> and
+    /// <see cref="DocumentsWriterFlushControl"/>, the <see cref="FlushPolicy"/> decides if a
+    /// <see cref="DocumentsWriterPerThread"/> needs flushing and mark it as flush-pending
+    /// via <see cref="DocumentsWriterFlushControl.SetFlushPending(ThreadState)"/>, or if deletes need
     /// to be applied.
     /// </summary>
-    /// <seealso cref= ThreadState </seealso>
-    /// <seealso cref= DocumentsWriterFlushControl </seealso>
-    /// <seealso cref= DocumentsWriterPerThread </seealso>
-    /// <seealso cref= IndexWriterConfig#setFlushPolicy(FlushPolicy) </seealso>
+    /// <seealso cref="ThreadState"/>
+    /// <seealso cref="DocumentsWriterFlushControl"/>
+    /// <seealso cref="DocumentsWriterPerThread"/>
+    /// <seealso cref="IndexWriterConfig.FlushPolicy"/>
 #if FEATURE_SERIALIZABLE
     [Serializable]
 #endif
@@ -62,21 +62,21 @@ namespace Lucene.Net.Index
 
         /// <summary>
         /// Called for each delete term. If this is a delete triggered due to an update
-        /// the given <seealso cref="ThreadState"/> is non-null.
-        /// <p>
+        /// the given <see cref="ThreadState"/> is non-null.
+        /// <para/>
         /// Note: this method is called synchronized on the given
-        /// <seealso cref="DocumentsWriterFlushControl"/> and it is guaranteed that the calling
-        /// thread holds the lock on the given <seealso cref="ThreadState"/>
+        /// <see cref="DocumentsWriterFlushControl"/> and it is guaranteed that the calling
+        /// thread holds the lock on the given <see cref="ThreadState"/>
         /// </summary>
         public abstract void OnDelete(DocumentsWriterFlushControl control, ThreadState state);
 
         /// <summary>
-        /// Called for each document update on the given <seealso cref="ThreadState"/>'s
-        /// <seealso cref="DocumentsWriterPerThread"/>.
-        /// <p>
+        /// Called for each document update on the given <see cref="ThreadState"/>'s
+        /// <see cref="DocumentsWriterPerThread"/>.
+        /// <para/>
         /// Note: this method is called  synchronized on the given
-        /// <seealso cref="DocumentsWriterFlushControl"/> and it is guaranteed that the calling
-        /// thread holds the lock on the given <seealso cref="ThreadState"/>
+        /// <see cref="DocumentsWriterFlushControl"/> and it is guaranteed that the calling
+        /// thread holds the lock on the given <see cref="ThreadState"/>
         /// </summary>
         public virtual void OnUpdate(DocumentsWriterFlushControl control, ThreadState state)
         {
@@ -85,17 +85,17 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Called for each document addition on the given <seealso cref="ThreadState"/>s
-        /// <seealso cref="DocumentsWriterPerThread"/>.
-        /// <p>
+        /// Called for each document addition on the given <see cref="ThreadState"/>s
+        /// <see cref="DocumentsWriterPerThread"/>.
+        /// <para/>
         /// Note: this method is synchronized by the given
-        /// <seealso cref="DocumentsWriterFlushControl"/> and it is guaranteed that the calling
-        /// thread holds the lock on the given <seealso cref="ThreadState"/>
+        /// <see cref="DocumentsWriterFlushControl"/> and it is guaranteed that the calling
+        /// thread holds the lock on the given <see cref="ThreadState"/>
         /// </summary>
         public abstract void OnInsert(DocumentsWriterFlushControl control, ThreadState state);
 
         /// <summary>
-        /// Called by DocumentsWriter to initialize the FlushPolicy
+        /// Called by <see cref="DocumentsWriter"/> to initialize the <see cref="FlushPolicy"/>
         /// </summary>
         protected internal virtual void Init(LiveIndexWriterConfig indexWriterConfig)
         {
@@ -107,10 +107,10 @@ namespace Lucene.Net.Index
         }
 
         /// <summary>
-        /// Returns the current most RAM consuming non-pending <seealso cref="ThreadState"/> with
+        /// Returns the current most RAM consuming non-pending <see cref="ThreadState"/> with
         /// at least one indexed document.
-        /// <p>
-        /// this method will never return <code>null</code>
+        /// <para/>
+        /// This method will never return <c>null</c>
         /// </summary>
         protected virtual ThreadState FindLargestNonPendingWriter(DocumentsWriterFlushControl control, ThreadState perThreadState)
         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/e6c2b88a/src/Lucene.Net/Index/FreqProxTermsWriter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Index/FreqProxTermsWriter.cs b/src/Lucene.Net/Index/FreqProxTermsWriter.cs
index 5c7c952..22f0ee7 100644
--- a/src/Lucene.Net/Index/FreqProxTermsWriter.cs
+++ b/src/Lucene.Net/Index/FreqProxTermsWriter.cs
@@ -32,12 +32,12 @@ namespace Lucene.Net.Index
     internal sealed class FreqProxTermsWriter : TermsHashConsumer
     {
         public override void Abort()
+        { }
+
         // TODO: would be nice to factor out more of this, eg the
         // FreqProxFieldMergeState, and code to visit all Fields
         // under the same FieldInfo together, up into TermsHash*.
         // Other writers would presumably share alot of this...
-        {
-        }
 
         public override void Flush(IDictionary<string, TermsHashConsumerPerField> fieldsToFlush, SegmentWriteState state)
         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/e6c2b88a/src/Lucene.Net/Index/FreqProxTermsWriterPerField.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Index/FreqProxTermsWriterPerField.cs b/src/Lucene.Net/Index/FreqProxTermsWriterPerField.cs
index 40d7936..8b108ce 100644
--- a/src/Lucene.Net/Index/FreqProxTermsWriterPerField.cs
+++ b/src/Lucene.Net/Index/FreqProxTermsWriterPerField.cs
@@ -396,10 +396,11 @@ namespace Lucene.Net.Index
 
         internal BytesRef payload;
 
-        /* Walk through all unique text tokens (Posting
-         * instances) found in this field and serialize them
-         * into a single RAM segment. */
-
+        /// <summary>
+        /// Walk through all unique text tokens (Posting
+        /// instances) found in this field and serialize them
+        /// into a single RAM segment.
+        /// </summary>
         internal void Flush(string fieldName, FieldsConsumer consumer, SegmentWriteState state)
         {
             if (!fieldInfo.IsIndexed)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/e6c2b88a/src/Lucene.Net/Index/FrozenBufferedUpdates.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Index/FrozenBufferedUpdates.cs b/src/Lucene.Net/Index/FrozenBufferedUpdates.cs
index 641699a..70dacef 100644
--- a/src/Lucene.Net/Index/FrozenBufferedUpdates.cs
+++ b/src/Lucene.Net/Index/FrozenBufferedUpdates.cs
@@ -41,23 +41,23 @@ namespace Lucene.Net.Index
 #endif
     internal class FrozenBufferedUpdates
     {
-        /* Query we often undercount (say 24 bytes), plus int. */
+        /// <summary>Query we often undercount (say 24 bytes), plus int.</summary>
         internal static readonly int BYTES_PER_DEL_QUERY = RamUsageEstimator.NUM_BYTES_OBJECT_REF + RamUsageEstimator.NUM_BYTES_INT32 + 24;
 
-        // Terms, in sorted order:
+        /// <summary>Terms, in sorted order:</summary>
         internal readonly PrefixCodedTerms terms;
 
         internal int termCount; // just for debugging
 
-        // Parallel array of deleted query, and the docIDUpto for each
+        /// <summary>Parallel array of deleted query, and the docIDUpto for each</summary>
         internal readonly Query[] queries;
 
         internal readonly int[] queryLimits;
 
-        // numeric DV update term and their updates
+        /// <summary>numeric DV update term and their updates</summary>
         internal readonly NumericDocValuesUpdate[] numericDVUpdates;
 
-        // binary DV update term and their updates
+        /// <summary>binary DV update term and their updates</summary>
         internal readonly BinaryDocValuesUpdate[] binaryDVUpdates;
 
         internal readonly int bytesUsed;


Mime
View raw message