Return-Path: <commits-return-4027-archive-asf-public=cust-asf.ponee.io@lucenenet.apache.org>
X-Original-To: archive-asf-public-internal@cust-asf2.ponee.io
Delivered-To: archive-asf-public-internal@cust-asf2.ponee.io
Received: from cust-asf.ponee.io (cust-asf.ponee.io [163.172.22.183])
	by cust-asf2.ponee.io (Postfix) with ESMTP id 16CF0200B8B
	for <archive-asf-public-internal@cust-asf2.ponee.io>; Tue,  4 Oct 2016 22:01:36 +0200 (CEST)
Received: by cust-asf.ponee.io (Postfix)
	id 14986160AF2; Tue,  4 Oct 2016 20:01:36 +0000 (UTC)
Delivered-To: archive-asf-public@cust-asf.ponee.io
Received: from mail.apache.org (hermes.apache.org [140.211.11.3])
	by cust-asf.ponee.io (Postfix) with SMTP id BEA92160AE9
	for <archive-asf-public@cust-asf.ponee.io>; Tue,  4 Oct 2016 22:01:33 +0200 (CEST)
Received: (qmail 22538 invoked by uid 500); 4 Oct 2016 20:01:32 -0000
Mailing-List: contact commits-help@lucenenet.apache.org; run by ezmlm
Precedence: bulk
List-Help: <mailto:commits-help@lucenenet.apache.org>
List-Unsubscribe: <mailto:commits-unsubscribe@lucenenet.apache.org>
List-Post: <mailto:commits@lucenenet.apache.org>
List-Id: <commits.lucenenet.apache.org>
Reply-To: lucene-net-dev@lucenenet.apache.org
Delivered-To: mailing list commits@lucenenet.apache.org
Received: (qmail 22184 invoked by uid 99); 4 Oct 2016 20:01:32 -0000
Received: from git1-us-west.apache.org (HELO git1-us-west.apache.org) (140.211.11.23)
    by apache.org (qpsmtpd/0.29) with ESMTP; Tue, 04 Oct 2016 20:01:32 +0000
Received: by git1-us-west.apache.org (ASF Mail Server at git1-us-west.apache.org, from userid 33)
	id 84BEEE6998; Tue,  4 Oct 2016 20:01:32 +0000 (UTC)
Content-Type: text/plain; charset="us-ascii"
MIME-Version: 1.0
Content-Transfer-Encoding: 7bit
From: synhershko@apache.org
To: commits@lucenenet.apache.org
Date: Tue, 04 Oct 2016 20:02:10 -0000
Message-Id: <9fbb804d6d6f4833a46e2ddc395131c9@git.apache.org>
In-Reply-To: <24a353907def438ca7013b548e833d9e@git.apache.org>
References: <24a353907def438ca7013b548e833d9e@git.apache.org>
X-Mailer: ASF-Git Admin Mailer
Subject: [40/46] lucenenet git commit: Facet: Updated documentation
archived-at: Tue, 04 Oct 2016 20:01:36 -0000

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/44958102/src/Lucene.Net.Facet/Taxonomy/CategoryPath.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/CategoryPath.cs b/src/Lucene.Net.Facet/Taxonomy/CategoryPath.cs
index ae177b6..9b52503 100644
--- a/src/Lucene.Net.Facet/Taxonomy/CategoryPath.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/CategoryPath.cs
@@ -31,19 +31,20 @@ namespace Lucene.Net.Facet.Taxonomy
     public class CategoryPath : IComparable<CategoryPath>
     {
         /// <summary>
-        /// An empty <seealso cref="CategoryPath"/> </summary>
+        /// An empty <see cref="CategoryPath"/>
+        /// </summary>
         public static readonly CategoryPath EMPTY = new CategoryPath();
 
         /// <summary>
-        /// The components of this <seealso cref="CategoryPath"/>. Note that this array may be
-        /// shared with other <seealso cref="CategoryPath"/> instances, e.g. as a result of
-        /// <seealso cref="#subpath(int)"/>, therefore you should traverse the array up to
-        /// <seealso cref="#length"/> for this path's components.
+        /// The components of this <see cref="CategoryPath"/>. Note that this array may be
+        /// shared with other <see cref="CategoryPath"/> instances, e.g. as a result of
+        /// <see cref="Subpath(int)"/>, therefore you should traverse the array up to
+        /// <see cref="Length"/> for this path's components.
         /// </summary>
         public string[] Components { get; private set; }
 
         /// <summary>
-        /// The number of components of this <seealso cref="CategoryPath"/>. </summary>
+        /// The number of components of this <see cref="CategoryPath"/>. </summary>
         public int Length { get; private set; }
 
         // Used by singleton EMPTY
@@ -65,7 +66,8 @@ namespace Lucene.Net.Facet.Taxonomy
         }
 
         /// <summary>
-        /// Construct from the given path components. </summary>
+        /// Construct from the given path <paramref name="components"/>.
+        /// </summary>
         public CategoryPath(params string[] components)
         {
             Debug.Assert(components.Length > 0, "use CategoryPath.EMPTY to create an empty path");
@@ -81,7 +83,8 @@ namespace Lucene.Net.Facet.Taxonomy
         }
 
         /// <summary>
-        /// Construct from a given path, separating path components with {@code delimiter}. </summary>
+        /// Construct from a given path, separating path components with <paramref name="delimiter"/>.
+        /// </summary>
         public CategoryPath(string pathString, char delimiter)
         {
             string[] comps = pathString.Split(new[] { delimiter }, StringSplitOptions.RemoveEmptyEntries);
@@ -107,7 +110,7 @@ namespace Lucene.Net.Facet.Taxonomy
         /// <summary>
         /// Returns the number of characters needed to represent the path, including
         /// delimiter characters, for using with
-        /// <seealso cref="#copyFullPath(char[], int, char)"/>.
+        /// <see cref="CopyFullPath(char[], int, char)"/>.
         /// </summary>
         public virtual int FullPathLength()
         {
@@ -126,7 +129,7 @@ namespace Lucene.Net.Facet.Taxonomy
         }
 
         /// <summary>
-        /// Compares this path with another <seealso cref="CategoryPath"/> for lexicographic
+        /// Compares this path with another <see cref="CategoryPath"/> for lexicographic
         /// order.
         /// </summary>
         public virtual int CompareTo(CategoryPath other)
@@ -167,14 +170,14 @@ namespace Lucene.Net.Facet.Taxonomy
         }
 
         /// <summary>
-        /// Copies the path components to the given {@code char[]}, starting at index
-        /// {@code start}. {@code delimiter} is copied between the path components.
+        /// Copies the path components to the given <see cref="char[]"/>, starting at index
+        /// <paramref name="start"/>. <paramref name="delimiter"/> is copied between the path components.
         /// Returns the number of chars copied.
         /// 
         /// <para>
         /// <b>NOTE:</b> this method relies on the array being large enough to hold the
         /// components and separators - the amount of needed space can be calculated
-        /// with <seealso cref="#fullPathLength()"/>.
+        /// with <see cref="FullPathLength()"/>.
         /// </para>
         /// </summary>
         public virtual int CopyFullPath(char[] buf, int start, char delimiter)
@@ -241,7 +244,8 @@ namespace Lucene.Net.Facet.Taxonomy
         }
 
         /// <summary>
-        /// Calculate a 64-bit hash function for this path. </summary>
+        /// Calculate a 64-bit hash function for this path.
+        /// </summary>
         public virtual long LongHashCode()
         {
             if (Length == 0)
@@ -258,7 +262,8 @@ namespace Lucene.Net.Facet.Taxonomy
         }
 
         /// <summary>
-        /// Returns a sub-path of this path up to {@code length} components. </summary>
+        /// Returns a sub-path of this path up to <paramref name="length"/> components.
+        /// </summary>
         public virtual CategoryPath Subpath(int length)
         {
             if (length >= this.Length || length < 0)
@@ -279,7 +284,7 @@ namespace Lucene.Net.Facet.Taxonomy
         /// Returns a string representation of the path, separating components with
         /// '/'.
         /// </summary>
-        /// <seealso cref= #toString(char) </seealso>
+        /// <see cref= #toString(char) </seealso>
         public override string ToString()
         {
             return ToString('/');

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/44958102/src/Lucene.Net.Facet/Taxonomy/Directory/DirectoryTaxonomyReader.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/Directory/DirectoryTaxonomyReader.cs b/src/Lucene.Net.Facet/Taxonomy/Directory/DirectoryTaxonomyReader.cs
index 4552f08..0949614 100644
--- a/src/Lucene.Net.Facet/Taxonomy/Directory/DirectoryTaxonomyReader.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/Directory/DirectoryTaxonomyReader.cs
@@ -34,8 +34,8 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
     using MultiFields = Lucene.Net.Index.MultiFields;
 
     /// <summary>
-    /// A <seealso cref="TaxonomyReader"/> which retrieves stored taxonomy information from a
-    /// <seealso cref="Directory"/>.
+    /// A <see cref="TaxonomyReader"/> which retrieves stored taxonomy information from a
+    /// <see cref="Directory"/>.
     /// <P>
     /// Reading from the on-disk index on every method call is too slow, so this
     /// implementation employs caching: Some methods cache recent requests and their
@@ -64,8 +64,8 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
         private volatile TaxonomyIndexArrays taxoArrays;
 
         /// <summary>
-        /// Called only from <seealso cref="#doOpenIfChanged()"/>. If the taxonomy has been
-        /// recreated, you should pass {@code null} as the caches and parent/children
+        /// Called only from <see cref="DoOpenIfChanged()"/>. If the taxonomy has been
+        /// recreated, you should pass <c>null</c> as the caches and parent/children
         /// arrays.
         /// </summary>
         internal DirectoryTaxonomyReader(DirectoryReader indexReader, DirectoryTaxonomyWriter taxoWriter, 
@@ -84,14 +84,11 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
         }
 
         /// <summary>
-        /// Open for reading a taxonomy stored in a given <seealso cref="Directory"/>.
+        /// Open for reading a taxonomy stored in a given <see cref="Directory"/>.
         /// </summary>
-        /// <param name="directory">
-        ///          The <seealso cref="Directory"/> in which the taxonomy resides. </param>
-        /// <exception cref="CorruptIndexException">
-        ///           if the Taxonomy is corrupt. </exception>
-        /// <exception cref="IOException">
-        ///           if another error occurred. </exception>
+        /// <param name="directory"> The <see cref="Directory"/> in which the taxonomy resides. </param>
+        /// <exception cref="Index.CorruptIndexException"> if the Taxonomy is corrupt. </exception>
+        /// <exception cref="IOException"> if another error occurred. </exception>
         public DirectoryTaxonomyReader(Directory directory)
         {
             indexReader = OpenIndexReader(directory);
@@ -106,11 +103,11 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
         }
 
         /// <summary>
-        /// Opens a <seealso cref="DirectoryTaxonomyReader"/> over the given
-        /// <seealso cref="DirectoryTaxonomyWriter"/> (for NRT).
+        /// Opens a <see cref="DirectoryTaxonomyReader"/> over the given
+        /// <see cref="DirectoryTaxonomyWriter"/> (for NRT).
         /// </summary>
         /// <param name="taxoWriter">
-        ///          The <seealso cref="DirectoryTaxonomyWriter"/> from which to obtain newly
+        ///          The <see cref="DirectoryTaxonomyWriter"/> from which to obtain newly
         ///          added categories, in real-time. </param>
         public DirectoryTaxonomyReader(DirectoryTaxonomyWriter taxoWriter)
         {
@@ -150,16 +147,16 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
         }
 
         /// <summary>
-        /// Implements the opening of a new <seealso cref="DirectoryTaxonomyReader"/> instance if
+        /// Implements the opening of a new <see cref="DirectoryTaxonomyReader"/> instance if
         /// the taxonomy has changed.
         /// 
         /// <para>
-        /// <b>NOTE:</b> the returned <seealso cref="DirectoryTaxonomyReader"/> shares the
+        /// <b>NOTE:</b> the returned <see cref="DirectoryTaxonomyReader"/> shares the
         /// ordinal and category caches with this reader. This is not expected to cause
         /// any issues, unless the two instances continue to live. The reader
         /// guarantees that the two instances cannot affect each other in terms of
         /// correctness of the caches, however if the size of the cache is changed
-        /// through <seealso cref="#setCacheSize(int)"/>, it will affect both reader instances.
+        /// through <see cref="CacheSize"/>, it will affect both reader instances.
         /// </para>
         /// </summary>
         protected override TaxonomyReader DoOpenIfChanged()
@@ -231,8 +228,7 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
         }
 
         /// <summary>
-        /// Open the <seealso cref="DirectoryReader"/> from this {@link
-        ///  Directory}. 
+        /// Open the <see cref="DirectoryReader"/> from this <see cref="Directory"/>. 
         /// </summary>
         protected virtual DirectoryReader OpenIndexReader(Directory directory)
         {
@@ -240,8 +236,7 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
         }
 
         /// <summary>
-        /// Open the <seealso cref="DirectoryReader"/> from this {@link
-        ///  IndexWriter}. 
+        /// Open the <see cref="DirectoryReader"/> from this <see cref="IndexWriter"/>. 
         /// </summary>
         protected virtual DirectoryReader OpenIndexReader(IndexWriter writer)
         {
@@ -249,8 +244,8 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
         }
 
         /// <summary>
-        /// Expert: returns the underlying <seealso cref="DirectoryReader"/> instance that is
-        /// used by this <seealso cref="TaxonomyReader"/>.
+        /// Expert: returns the underlying <see cref="DirectoryReader"/> instance that is
+        /// used by this <see cref="TaxonomyReader"/>.
         /// </summary>
         internal virtual DirectoryReader InternalIndexReader
         {
@@ -379,13 +374,13 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
         }
 
         /// <summary>
-        /// setCacheSize controls the maximum allowed size of each of the caches
-        /// used by <seealso cref="#getPath(int)"/> and <seealso cref="#getOrdinal(FacetLabel)"/>.
+        /// Setting <see cref="CacheSize"/> controls the maximum allowed size of each of the caches
+        /// used by <see cref="GetPath(int)"/> and <see cref="GetOrdinal(FacetLabel)"/>.
         /// <P>
         /// Currently, if the given size is smaller than the current size of
         /// a cache, it will not shrink, and rather we be limited to its current
         /// size. </summary>
-        /// <param name="size"> the new maximum cache size, in number of entries. </param>
+        /// <param name="value"> the new maximum cache size, in number of entries. </param>
         public virtual int CacheSize
         {
             set
@@ -400,8 +395,8 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
 
         /// <summary>
         /// Returns ordinal -> label mapping, up to the provided
-        ///  max ordinal or number of ordinals, whichever is
-        ///  smaller. 
+        /// max ordinal or number of ordinals, whichever is
+        /// smaller. 
         /// </summary>
         public virtual string ToString(int max)
         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/44958102/src/Lucene.Net.Facet/Taxonomy/Directory/DirectoryTaxonomyWriter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/Directory/DirectoryTaxonomyWriter.cs b/src/Lucene.Net.Facet/Taxonomy/Directory/DirectoryTaxonomyWriter.cs
index dd497fd..f59337e 100644
--- a/src/Lucene.Net.Facet/Taxonomy/Directory/DirectoryTaxonomyWriter.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/Directory/DirectoryTaxonomyWriter.cs
@@ -54,20 +54,20 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
     using TokenStream = Lucene.Net.Analysis.TokenStream;
 
     /// <summary>
-    /// <seealso cref="TaxonomyWriter"/> which uses a <seealso cref="Directory"/> to store the taxonomy
+    /// <see cref="ITaxonomyWriter"/> which uses a <see cref="Store.Directory"/> to store the taxonomy
     /// information on disk, and keeps an additional in-memory cache of some or all
     /// categories.
     /// <para>
-    /// In addition to the permanently-stored information in the <seealso cref="Directory"/>,
-    /// efficiency dictates that we also keep an in-memory cache of <B>recently
-    /// seen</B> or <B>all</B> categories, so that we do not need to go back to disk
+    /// In addition to the permanently-stored information in the <see cref="Store.Directory"/>,
+    /// efficiency dictates that we also keep an in-memory cache of <b>recently
+    /// seen</b> or <b>all</b> categories, so that we do not need to go back to disk
     /// for every category addition to see which ordinal this category already has,
-    /// if any. A <seealso cref="TaxonomyWriterCache"/> object determines the specific caching
+    /// if any. A <see cref="ITaxonomyWriterCache"/> object determines the specific caching
     /// algorithm used.
     /// </para>
     /// <para>
     /// This class offers some hooks for extending classes to control the
-    /// <seealso cref="IndexWriter"/> instance that is used. See <seealso cref="#openIndexWriter"/>.
+    /// <see cref="IndexWriter"/> instance that is used. See <see cref="OpenIndexWriter"/>.
     /// 
     /// @lucene.experimental
     /// </para>
@@ -77,7 +77,7 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
         /// <summary>
         /// Property name of user commit data that contains the index epoch. The epoch
         /// changes whenever the taxonomy is recreated (i.e. opened with
-        /// <seealso cref="OpenMode#CREATE"/>.
+        /// <see cref="OpenMode.CREATE"/>.
         /// <para>
         /// Applications should not use this property in their commit data because it
         /// will be overridden by this taxonomy writer.
@@ -107,12 +107,12 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
 
         /// <summary>
         /// We call the cache "complete" if we know that every category in our
-        /// taxonomy is in the cache. When the cache is <B>not</B> complete, and
+        /// taxonomy is in the cache. When the cache is <b>not</b> complete, and
         /// we can't find a category in the cache, we still need to look for it
         /// in the on-disk index; Therefore when the cache is not complete, we
         /// need to open a "reader" to the taxonomy index.
         /// The cache becomes incomplete if it was never filled with the existing
-        /// categories, or if a put() to the cache ever returned true (meaning
+        /// categories, or if a Put() to the cache ever returned true (meaning
         /// that some of the cached data was cleared).
         /// </summary>
         private volatile bool cacheIsComplete;
@@ -121,7 +121,7 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
         private volatile int nextID;
 
         /// <summary>
-        /// Reads the commit data from a Directory. </summary>
+        /// Reads the commit data from a <see cref="Store.Directory"/>. </summary>
         private static IDictionary<string, string> ReadCommitData(Directory dir)
         {
             SegmentInfos infos = new SegmentInfos();
@@ -136,9 +136,9 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
         /// known that no other process nor thread is in fact currently accessing
         /// this taxonomy.
         /// <P>
-        /// This method is unnecessary if your <seealso cref="Directory"/> uses a
-        /// <seealso cref="NativeFSLockFactory"/> instead of the default
-        /// <seealso cref="SimpleFSLockFactory"/>. When the "native" lock is used, a lock
+        /// This method is unnecessary if your <see cref="Store.Directory"/> uses a
+        /// <see cref="NativeFSLockFactory"/> instead of the default
+        /// <see cref="SimpleFSLockFactory"/>. When the "native" lock is used, a lock
         /// does not stay behind forever when the process using it dies. 
         /// </summary>
         public static void Unlock(Directory directory)
@@ -150,28 +150,28 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
         /// Construct a Taxonomy writer.
         /// </summary>
         /// <param name="directory">
-        ///    The <seealso cref="Directory"/> in which to store the taxonomy. Note that
+        ///    The <see cref="Store.Directory"/> in which to store the taxonomy. Note that
         ///    the taxonomy is written directly to that directory (not to a
         ///    subdirectory of it). </param>
         /// <param name="openMode">
-        ///    Specifies how to open a taxonomy for writing: <code>APPEND</code>
+        ///    Specifies how to open a taxonomy for writing: <see cref="OpenMode.APPEND"/>
         ///    means open an existing index for append (failing if the index does
-        ///    not yet exist). <code>CREATE</code> means create a new index (first
+        ///    not yet exist). <see cref="OpenMode.CREATE"/> means create a new index (first
         ///    deleting the old one if it already existed).
-        ///    <code>APPEND_OR_CREATE</code> appends to an existing index if there
+        ///    <see cref="OpenMode.CREATE_OR_APPEND"/> appends to an existing index if there
         ///    is one, otherwise it creates a new index. </param>
         /// <param name="cache">
-        ///    A <seealso cref="TaxonomyWriterCache"/> implementation which determines
+        ///    A <see cref="ITaxonomyWriterCache"/> implementation which determines
         ///    the in-memory caching policy. See for example
-        ///    <seealso cref="LruTaxonomyWriterCache"/> and <seealso cref="Cl2oTaxonomyWriterCache"/>.
-        ///    If null or missing, <seealso cref="#defaultTaxonomyWriterCache()"/> is used. </param>
+        ///    <see cref="WriterCache.LruTaxonomyWriterCache"/> and <see cref="Cl2oTaxonomyWriterCache"/>.
+        ///    If null or missing, <see cref="DefaultTaxonomyWriterCache()"/> is used. </param>
         /// <exception cref="CorruptIndexException">
         ///     if the taxonomy is corrupted. </exception>
         /// <exception cref="LockObtainFailedException">
         ///     if the taxonomy is locked by another writer. If it is known
         ///     that no other concurrent writer is active, the lock might
         ///     have been left around by an old dead process, and should be
-        ///     removed using <seealso cref="#unlock(Directory)"/>. </exception>
+        ///     removed using <see cref="Unlock(Directory)"/>. </exception>
         /// <exception cref="IOException">
         ///     if another error occurred. </exception>
         public DirectoryTaxonomyWriter(Directory directory, OpenMode openMode, 
@@ -250,18 +250,17 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
         /// <summary>
         /// Open internal index writer, which contains the taxonomy data.
         /// <para>
-        /// Extensions may provide their own <seealso cref="IndexWriter"/> implementation or instance. 
-        /// <br><b>NOTE:</b> the instance this method returns will be closed upon calling
-        /// to <seealso cref="#close()"/>.
+        /// Extensions may provide their own <see cref="IndexWriter"/> implementation or instance. 
+        /// <br><b>NOTE:</b> the instance this method returns will be disposed upon calling
+        /// to <see cref="Dispose()"/>.
         /// <br><b>NOTE:</b> the merge policy in effect must not merge none adjacent segments. See
-        /// comment in <seealso cref="#createIndexWriterConfig(IndexWriterConfig.OpenMode)"/> for the logic behind this.
+        /// comment in <see cref="CreateIndexWriterConfig(IndexWriterConfig.OpenMode)"/> for the logic behind this.
         ///  
         /// </para>
         /// </summary>
-        /// <seealso cref= #createIndexWriterConfig(IndexWriterConfig.OpenMode)
-        /// </seealso>
+        /// <seealso cref="CreateIndexWriterConfig(IndexWriterConfig.OpenMode)"/>
         /// <param name="directory">
-        ///          the <seealso cref="Directory"/> on top of which an <seealso cref="IndexWriter"/>
+        ///          the <see cref="Store.Directory"/> on top of which an <see cref="IndexWriter"/>
         ///          should be opened. </param>
         /// <param name="config">
         ///          configuration for the internal index writer. </param>
@@ -271,18 +270,17 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
         }
 
         /// <summary>
-        /// Create the <seealso cref="IndexWriterConfig"/> that would be used for opening the internal index writer.
-        /// <br>Extensions can configure the <seealso cref="IndexWriter"/> as they see fit,
-        /// including setting a <seealso cref="Lucene.Net.index.MergeScheduler merge-scheduler"/>, or
-        /// <seealso cref="Lucene.Net.index.IndexDeletionPolicy deletion-policy"/>, different RAM size
+        /// Create the <see cref="IndexWriterConfig"/> that would be used for opening the internal index writer.
+        /// <br>Extensions can configure the <see cref="IndexWriter"/> as they see fit,
+        /// including setting a <see cref="Index.MergeScheduler"/>, or
+        /// <see cref="Index.IndexDeletionPolicy"/>, different RAM size
         /// etc.<br>
         /// <br><b>NOTE:</b> internal docids of the configured index must not be altered.
         /// For that, categories are never deleted from the taxonomy index.
         /// In addition, merge policy in effect must not merge none adjacent segments.
         /// </summary>
-        /// <seealso cref= #openIndexWriter(Directory, IndexWriterConfig)
-        /// </seealso>
-        /// <param name="openMode"> see <seealso cref="OpenMode"/> </param>
+        /// <seealso cref="OpenIndexWriter(Directory, IndexWriterConfig)"/>
+        /// <param name="openMode"> see <see cref="OpenMode"/> </param>
         protected virtual IndexWriterConfig CreateIndexWriterConfig(OpenMode openMode)
         {
             // TODO: should we use a more optimized Codec, e.g. Pulsing (or write custom)?
@@ -295,7 +293,7 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
         }
 
         /// <summary>
-        /// Opens a <seealso cref="ReaderManager"/> from the internal <seealso cref="IndexWriter"/>. 
+        /// Opens a <see cref="ReaderManager"/> from the internal <see cref="IndexWriter"/>. 
         /// </summary>
         private void InitReaderManager()
         {
@@ -317,7 +315,7 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
 
         /// <summary>
         /// Creates a new instance with a default cache as defined by
-        /// <seealso cref="#defaultTaxonomyWriterCache()"/>.
+        /// <see cref="DefaultTaxonomyWriterCache()"/>.
         /// </summary>
         public DirectoryTaxonomyWriter(Directory directory, OpenMode openMode = OpenMode.CREATE_OR_APPEND)
             : this(directory, openMode, DefaultTaxonomyWriterCache())
@@ -325,12 +323,13 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
         }
 
         /// <summary>
-        /// Defines the default <seealso cref="TaxonomyWriterCache"/> to use in constructors
+        /// Defines the default <see cref="ITaxonomyWriterCache"/> to use in constructors
         /// which do not specify one.
-        /// <P>  
-        /// The current default is <seealso cref="Cl2oTaxonomyWriterCache"/> constructed
+        /// <para>  
+        /// The current default is <see cref="Cl2oTaxonomyWriterCache"/> constructed
         /// with the parameters (1024, 0.15f, 3), i.e., the entire taxonomy is
         /// cached in memory while building it.
+        /// </para>
         /// </summary>
         public static ITaxonomyWriterCache DefaultTaxonomyWriterCache()
         {
@@ -338,9 +337,9 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
         }
 
         /// <summary>
-        /// Frees used resources as well as closes the underlying <seealso cref="IndexWriter"/>,
+        /// Frees used resources as well as closes the underlying <see cref="IndexWriter"/>,
         /// which commits whatever changes made to it to the underlying
-        /// <seealso cref="Directory"/>.
+        /// <see cref="Store.Directory"/>.
         /// </summary>
         public void Dispose()
         {
@@ -363,10 +362,12 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
 
         /// <summary>
         /// A hook for extending classes to close additional resources that were used.
-        /// The default implementation closes the <seealso cref="IndexReader"/> as well as the
-        /// <seealso cref="TaxonomyWriterCache"/> instances that were used. <br>
+        /// The default implementation closes the <see cref="Index.IndexReader"/> as well as the
+        /// <see cref="ITaxonomyWriterCache"/> instances that were used.
+        /// <para>
         /// <b>NOTE:</b> if you override this method, you should include a
-        /// <code>super.closeResources()</code> call in your implementation.
+        /// <c>base.CloseResources()</c> call in your implementation.
+        /// </para>
         /// </summary>
         protected virtual void CloseResources()
         {
@@ -529,7 +530,7 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
 
         /// <summary>
         /// Verifies that this instance wasn't closed, or throws
-        /// <seealso cref="AlreadyClosedException"/> if it is.
+        /// <see cref="AlreadyClosedException"/> if it is.
         /// </summary>
         protected internal void EnsureOpen()
         {
@@ -540,7 +541,7 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
         }
 
         /// <summary>
-        /// Note that the methods calling addCategoryDocument() are synchornized, so
+        /// Note that the methods calling <see cref="AddCategoryDocument"/> are synchornized, so
         /// this method is effectively synchronized as well.
         /// </summary>
         private int AddCategoryDocument(FacetLabel categoryPath, int parent)
@@ -598,15 +599,16 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
 
             /// <summary>
             /// Set the value we want to keep, as the position increment.
-            /// Note that when TermPositions.nextPosition() is later used to
+            /// Note that when TermPositions.NextPosition() is later used to
             /// retrieve this value, val-1 will be returned, not val.
-            /// <P>
+            /// <para>
             /// IMPORTANT NOTE: Before Lucene 2.9, val>=0 were safe (for val==0,
             /// the retrieved position would be -1). But starting with Lucene 2.9,
             /// this unfortunately changed, and only val>0 are safe. val=0 can
             /// still be used, but don't count on the value you retrieve later
             /// (it could be 0 or -1, depending on circumstances or versions).
-            /// This change is described in Lucene's JIRA: LUCENE-1542. 
+            /// This change is described in Lucene's JIRA: LUCENE-1542.
+            /// </para>
             /// </summary>
             public virtual void Set(int val)
             {
@@ -679,7 +681,8 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
         }
 
         /// <summary>
-        /// Combine original user data with the taxonomy epoch. </summary>
+        /// Combine original user data with the taxonomy epoch.
+        /// </summary>
         private IDictionary<string, string> CombinedCommitData(IDictionary<string, string> commitData)
         {
             IDictionary<string, string> m = new Dictionary<string, string>();
@@ -706,7 +709,7 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
 
         /// <summary>
         /// prepare most of the work needed for a two-phase commit.
-        /// See <seealso cref="IndexWriter#prepareCommit"/>.
+        /// See <see cref="IndexWriter.PrepareCommit"/>.
         /// </summary>
         public virtual void PrepareCommit()
         {
@@ -744,7 +747,7 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
         /// after a certain number (defined by this method) of cache misses.
         /// </para>
         /// <para>
-        /// If the number is set to {@code 0}, the entire taxonomy is read into the
+        /// If the number is set to <c>0</c>, the entire taxonomy is read into the
         /// cache on first use, without fetching individual categories first.
         /// </para>
         /// <para>
@@ -894,7 +897,7 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
         /// <summary>
         /// Takes the categories from the given taxonomy directory, and adds the
         /// missing ones to this taxonomy. Additionally, it fills the given
-        /// <seealso cref="OrdinalMap"/> with a mapping from the original ordinal to the new
+        /// <see cref="IOrdinalMap"/> with a mapping from the original ordinal to the new
         /// ordinal.
         /// </summary>
         public virtual void AddTaxonomy(Directory taxoDir, IOrdinalMap map)
@@ -935,13 +938,13 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
         /// Mapping from old ordinal to new ordinals, used when merging indexes 
         /// wit separate taxonomies.
         /// <para> 
-        /// addToTaxonomies() merges one or more taxonomies into the given taxonomy
-        /// (this). An IOrdinalMap is filled for each of the added taxonomies,
+        /// <see cref="AddMapping"/> merges one or more taxonomies into the given taxonomy
+        /// (this). An <see cref="IOrdinalMap"/> is filled for each of the added taxonomies,
         /// containing the new ordinal (in the merged taxonomy) of each of the
         /// categories in the old taxonomy.
         /// <P>  
-        /// There exist two implementations of IOrdinalMap: MemoryOrdinalMap and
-        /// DiskOrdinalMap. As their names suggest, the former keeps the map in
+        /// There exist two implementations of <see cref="IOrdinalMap"/>: <see cref="MemoryOrdinalMap"/> and
+        /// <see cref="DiskOrdinalMap"/>. As their names suggest, the former keeps the map in
         /// memory and the latter in a temporary disk file. Because these maps will
         /// later be needed one by one (to remap the counting lists), not all at the
         /// same time, it is recommended to put the first taxonomy's map in memory,
@@ -952,10 +955,10 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
         public interface IOrdinalMap
         {
             /// <summary>
-            /// Set the size of the map. This MUST be called before addMapping().
-            /// It is assumed (but not verified) that addMapping() will then be
-            /// called exactly 'size' times, with different origOrdinals between 0
-            /// and size-1.  
+            /// Set the size of the map. This MUST be called before <see cref="AddMapping"/>.
+            /// It is assumed (but not verified) that <see cref="AddMapping"/> will then be
+            /// called exactly 'size' times, with different <paramref name="origOrdinals"/> between 0
+            /// and size - 1.  
             /// </summary>
             void SetSize(int taxonomySize);
 
@@ -964,7 +967,7 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
             void AddMapping(int origOrdinal, int newOrdinal);
 
             /// <summary>
-            /// Call addDone() to say that all addMapping() have been done.
+            /// Call <see cref="AddDone()"/> to say that all <see cref="AddMapping"/> have been done.
             /// In some implementations this might free some resources. 
             /// </summary>
             void AddDone();
@@ -981,7 +984,7 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
         }
 
         /// <summary>
-        /// <seealso cref="OrdinalMap"/> maintained in memory
+        /// <see cref="IOrdinalMap"/> maintained in memory
         /// </summary>
         public sealed class MemoryOrdinalMap : IOrdinalMap
         {
@@ -1026,7 +1029,7 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
         }
 
         /// <summary>
-        /// <seealso cref="OrdinalMap"/> maintained on file system
+        /// <see cref="IOrdinalMap"/> maintained on file system
         /// </summary>
         public sealed class DiskOrdinalMap : IOrdinalMap
         {
@@ -1102,7 +1105,7 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
         /// <summary>
         /// Rollback changes to the taxonomy writer and closes the instance. Following
         /// this method the instance becomes unusable (calling any of its API methods
-        /// will yield an <seealso cref="AlreadyClosedException"/>).
+        /// will yield an <see cref="AlreadyClosedException"/>).
         /// </summary>
         public virtual void Rollback()
         {
@@ -1117,7 +1120,7 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
         /// <summary>
         /// Replaces the current taxonomy with the given one. This method should
         /// generally be called in conjunction with
-        /// <seealso cref="IndexWriter#addIndexes(Directory...)"/> to replace both the taxonomy
+        /// <see cref="IndexWriter.AddIndexes(Directory[])"/> to replace both the taxonomy
         /// as well as the search index content.
         /// </summary>
         public virtual void ReplaceTaxonomy(Directory taxoDir)
@@ -1146,7 +1149,8 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
         }
 
         /// <summary>
-        /// Returns the <seealso cref="Directory"/> of this taxonomy writer. </summary>
+        /// Returns the <see cref="Store.Directory"/> of this taxonomy writer.
+        /// </summary>
         public virtual Directory Directory
         {
             get
@@ -1156,9 +1160,9 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
         }
 
         /// <summary>
-        /// Used by <seealso cref="DirectoryTaxonomyReader"/> to support NRT.
+        /// Used by <see cref="DirectoryTaxonomyReader"/> to support NRT.
         /// <para>
-        /// <b>NOTE:</b> you should not use the obtained <seealso cref="IndexWriter"/> in any
+        /// <b>NOTE:</b> you should not use the obtained <see cref="IndexWriter"/> in any
         /// way, other than opening an IndexReader on it, or otherwise, the taxonomy
         /// index may become corrupt!
         /// </para>
@@ -1173,8 +1177,8 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
 
         /// <summary>
         /// Expert: returns current index epoch, if this is a
-        /// near-real-time reader.  Used by {@link
-        /// DirectoryTaxonomyReader} to support NRT. 
+        /// near-real-time reader.  Used by 
+        /// <see cref="DirectoryTaxonomyReader"/> to support NRT. 
         /// 
         /// @lucene.internal 
         /// </summary>

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/44958102/src/Lucene.Net.Facet/Taxonomy/Directory/TaxonomyIndexArrays.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/Directory/TaxonomyIndexArrays.cs b/src/Lucene.Net.Facet/Taxonomy/Directory/TaxonomyIndexArrays.cs
index 9cbaaed..a261374 100644
--- a/src/Lucene.Net.Facet/Taxonomy/Directory/TaxonomyIndexArrays.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/Directory/TaxonomyIndexArrays.cs
@@ -28,7 +28,7 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
     using MultiFields = Lucene.Net.Index.MultiFields;
 
     /// <summary>
-    /// A <seealso cref="ParallelTaxonomyArrays"/> that are initialized from the taxonomy
+    /// A <see cref="ParallelTaxonomyArrays"/> that are initialized from the taxonomy
     /// index.
     /// 
     /// @lucene.experimental
@@ -45,7 +45,8 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
         private int[] children, siblings;
 
         /// <summary>
-        /// Used by <seealso cref="#add(int, int)"/> after the array grew. </summary>
+        /// Used by <see cref="Add(int, int)"/> after the array grew.
+        /// </summary>
         private TaxonomyIndexArrays(int[] parents)
         {
             this.parents = parents;
@@ -137,7 +138,9 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
             }
         }
 
-        // Read the parents of the new categories
+        /// <summary>
+        /// Read the parents of the new categories
+        /// </summary>
         private void InitParents(IndexReader reader, int first)
         {
             if (reader.MaxDoc == first)
@@ -204,8 +207,8 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
         }
 
         /// <summary>
-        /// Returns the parents array, where {@code parents[i]} denotes the parent of
-        /// category ordinal {@code i}.
+        /// Returns the parents array, where <c>Parents[i]</c> denotes the parent of
+        /// category ordinal <c>i</c>.
         /// </summary>
         public override int[] Parents
         {
@@ -216,10 +219,10 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
         }
 
         /// <summary>
-        /// Returns the children array, where {@code children[i]} denotes the youngest
-        /// child of category ordinal {@code i}. The youngest child is defined as the
+        /// Returns the children array, where <c>Children[i]</c> denotes the youngest
+        /// child of category ordinal <c>i</c>. The youngest child is defined as the
         /// category that was added last to the taxonomy as an immediate child of
-        /// {@code i}.
+        /// <c>i</c>.
         /// </summary>
         public override int[] Children
         {
@@ -236,9 +239,9 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
         }
 
         /// <summary>
-        /// Returns the siblings array, where {@code siblings[i]} denotes the sibling
-        /// of category ordinal {@code i}. The sibling is defined as the previous
-        /// youngest child of {@code parents[i]}.
+        /// Returns the siblings array, where <c>Siblings[i]</c> denotes the sibling
+        /// of category ordinal <c>i</c>. The sibling is defined as the previous
+        /// youngest child of <c>Parents[i]</c>.
         /// </summary>
         public override int[] Siblings
         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/44958102/src/Lucene.Net.Facet/Taxonomy/DocValuesOrdinalsReader.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/DocValuesOrdinalsReader.cs b/src/Lucene.Net.Facet/Taxonomy/DocValuesOrdinalsReader.cs
index 3d5cc53..b48eafd 100644
--- a/src/Lucene.Net.Facet/Taxonomy/DocValuesOrdinalsReader.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/DocValuesOrdinalsReader.cs
@@ -25,21 +25,23 @@
     using IntsRef = Lucene.Net.Util.IntsRef;
 
     /// <summary>
-    /// Decodes ordinals previously indexed into a BinaryDocValues field </summary>
-
+    /// Decodes ordinals previously indexed into a <see cref="BinaryDocValues"/> field
+    /// </summary>
     public class DocValuesOrdinalsReader : OrdinalsReader
     {
         private readonly string field;
 
         /// <summary>
-        /// Default constructor. </summary>
+        /// Default constructor.
+        /// </summary>
         public DocValuesOrdinalsReader()
             : this(FacetsConfig.DEFAULT_INDEX_FIELD_NAME)
         {
         }
 
         /// <summary>
-        /// Create this, with the specified indexed field name. </summary>
+        /// Create this, with the specified indexed field name.
+        /// </summary>
         public DocValuesOrdinalsReader(string field)
         {
             this.field = field;
@@ -87,7 +89,8 @@
         }
 
         /// <summary>
-        /// Subclass & override if you change the encoding. </summary>
+        /// Subclass & override if you change the encoding.
+        /// </summary>
         protected virtual void Decode(BytesRef buf, IntsRef ordinals)
         {
 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/44958102/src/Lucene.Net.Facet/Taxonomy/FacetLabel.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/FacetLabel.cs b/src/Lucene.Net.Facet/Taxonomy/FacetLabel.cs
index edc68c0..56a16af 100644
--- a/src/Lucene.Net.Facet/Taxonomy/FacetLabel.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/FacetLabel.cs
@@ -40,20 +40,21 @@ namespace Lucene.Net.Facet.Taxonomy
          * be on the safe side.
          */
         /// <summary>
-        /// The maximum number of characters a <seealso cref="FacetLabel"/> can have.
+        /// The maximum number of characters a <see cref="FacetLabel"/> can have.
         /// </summary>
         public static readonly int MAX_CATEGORY_PATH_LENGTH = (BYTE_BLOCK_SIZE - 2) / 4;
 
         /// <summary>
-        /// The components of this <seealso cref="FacetLabel"/>. Note that this array may be
-        /// shared with other <seealso cref="FacetLabel"/> instances, e.g. as a result of
-        /// <seealso cref="#subpath(int)"/>, therefore you should traverse the array up to
-        /// <seealso cref="#length"/> for this path's components.
+        /// The components of this <see cref="FacetLabel"/>. Note that this array may be
+        /// shared with other <see cref="FacetLabel"/> instances, e.g. as a result of
+        /// <see cref="Subpath(int)"/>, therefore you should traverse the array up to
+        /// <see cref="Length"/> for this path's components.
         /// </summary>
         public string[] Components { get; private set; }
 
         /// <summary>
-        /// The number of components of this <seealso cref="FacetLabel"/>. </summary>
+        /// The number of components of this <see cref="FacetLabel"/>.
+        /// </summary>
         public int Length { get; private set; }
 
         // Used by subpath
@@ -68,7 +69,8 @@ namespace Lucene.Net.Facet.Taxonomy
         }
 
         /// <summary>
-        /// Construct from the given path components. </summary>
+        /// Construct from the given path components.
+        /// </summary>
         public FacetLabel(params string[] components)
         {
             this.Components = components;
@@ -77,7 +79,8 @@ namespace Lucene.Net.Facet.Taxonomy
         }
 
         /// <summary>
-        /// Construct from the dimension plus the given path components. </summary>
+        /// Construct from the dimension plus the given path components.
+        /// </summary>
         public FacetLabel(string dim, string[] path)
         {
             Components = new string[1 + path.Length];
@@ -106,7 +109,7 @@ namespace Lucene.Net.Facet.Taxonomy
         }
 
         /// <summary>
-        /// Compares this path with another <seealso cref="FacetLabel"/> for lexicographic
+        /// Compares this path with another <see cref="FacetLabel"/> for lexicographic
         /// order.
         /// </summary>
         public virtual int CompareTo(FacetLabel other)
@@ -171,10 +174,9 @@ namespace Lucene.Net.Facet.Taxonomy
 
         /// <summary>
         /// Calculate a 64-bit hash function for this path.  This
-        ///  is necessary for <seealso cref="NameHashIntCacheLRU"/> (the
-        ///  default cache impl for {@link
-        ///  LruTaxonomyWriterCache}) to reduce the chance of
-        ///  "silent but deadly" collisions. 
+        /// is necessary for <see cref="NameHashIntCacheLRU"/> (the
+        /// default cache impl for <see cref="LruTaxonomyWriterCache"/>) 
+        /// to reduce the chance of "silent but deadly" collisions. 
         /// </summary>
         public virtual long LongHashCode()
         {
@@ -192,16 +194,17 @@ namespace Lucene.Net.Facet.Taxonomy
         }
 
         /// <summary>
-        /// Returns a sub-path of this path up to {@code length} components. </summary>
-        public virtual FacetLabel Subpath(int len)
+        /// Returns a sub-path of this path up to <paramref name="length"/> components.
+        /// </summary>
+        public virtual FacetLabel Subpath(int length)
         {
-            if (len >= this.Length || len < 0)
+            if (length >= this.Length || length < 0)
             {
                 return this;
             }
             else
             {
-                return new FacetLabel(this, len);
+                return new FacetLabel(this, length);
             }
         }
 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/44958102/src/Lucene.Net.Facet/Taxonomy/FastTaxonomyFacetCounts.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/FastTaxonomyFacetCounts.cs b/src/Lucene.Net.Facet/Taxonomy/FastTaxonomyFacetCounts.cs
index 3511af8..6cb5043 100644
--- a/src/Lucene.Net.Facet/Taxonomy/FastTaxonomyFacetCounts.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/FastTaxonomyFacetCounts.cs
@@ -26,15 +26,15 @@ namespace Lucene.Net.Facet.Taxonomy
 
     /// <summary>
     /// Computes facets counts, assuming the default encoding
-    ///  into DocValues was used.
+    /// into DocValues was used.
     /// 
     /// @lucene.experimental 
     /// </summary>
     public class FastTaxonomyFacetCounts : IntTaxonomyFacets
     {
         /// <summary>
-        /// Create {@code FastTaxonomyFacetCounts}, which also
-        ///  counts all facet labels. 
+        /// Create <see cref="FastTaxonomyFacetCounts"/>, which also
+        /// counts all facet labels. 
         /// </summary>
         public FastTaxonomyFacetCounts(TaxonomyReader taxoReader, FacetsConfig config, FacetsCollector fc)
             : this(FacetsConfig.DEFAULT_INDEX_FIELD_NAME, taxoReader, config, fc)
@@ -42,11 +42,11 @@ namespace Lucene.Net.Facet.Taxonomy
         }
 
         /// <summary>
-        /// Create {@code FastTaxonomyFacetCounts}, using the
-        ///  specified {@code indexFieldName} for ordinals.  Use
-        ///  this if you had set {@link
-        ///  FacetsConfig#setIndexFieldName} to change the index
-        ///  field name for certain dimensions. 
+        /// Create <see cref="FastTaxonomyFacetCounts"/>, using the
+        /// specified <paramref name="indexFieldName"/> for ordinals.  Use
+        /// this if you had set <see cref="FacetsConfig.SetIndexFieldName"/>
+        /// to change the index
+        /// field name for certain dimensions. 
         /// </summary>
         public FastTaxonomyFacetCounts(string indexFieldName, TaxonomyReader taxoReader, FacetsConfig config, FacetsCollector fc)
             : base(indexFieldName, taxoReader, config)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/44958102/src/Lucene.Net.Facet/Taxonomy/FloatAssociationFacetField.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/FloatAssociationFacetField.cs b/src/Lucene.Net.Facet/Taxonomy/FloatAssociationFacetField.cs
index 1b070a6..dbcf615 100644
--- a/src/Lucene.Net.Facet/Taxonomy/FloatAssociationFacetField.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/FloatAssociationFacetField.cs
@@ -24,18 +24,17 @@ namespace Lucene.Net.Facet.Taxonomy
     using Document = Lucene.Net.Documents.Document;
 
     /// <summary>
-    /// Add an instance of this to your <seealso cref="Document"/> to add
-    ///  a facet label associated with a float.  Use {@link
-    ///  TaxonomyFacetSumFloatAssociations} to aggregate float values
-    ///  per facet label at search time.
+    /// Add an instance of this to your <see cref="Document"/> to add
+    /// a facet label associated with a float.  Use <see cref="TaxonomyFacetSumFloatAssociations"/>
+    /// to aggregate float values per facet label at search time.
     /// 
     ///  @lucene.experimental 
     /// </summary>
     public class FloatAssociationFacetField : AssociationFacetField
     {
         /// <summary>
-        /// Creates this from {@code dim} and {@code path} and a
-        ///  float association 
+        /// Creates this from <paramref name="dim"/> and <paramref name="path"/> and a
+        /// float association 
         /// </summary>
         public FloatAssociationFacetField(float assoc, string dim, params string[] path) 
             : base(FloatToBytesRef(assoc), dim, path)
@@ -43,14 +42,16 @@ namespace Lucene.Net.Facet.Taxonomy
         }
 
         /// <summary>
-        /// Encodes a {@code float} as a 4-byte <seealso cref="BytesRef"/>. </summary>
+        /// Encodes a <see cref="float"/> as a 4-byte <see cref="BytesRef"/>.
+        /// </summary>
         public static BytesRef FloatToBytesRef(float v)
         {
             return IntAssociationFacetField.IntToBytesRef(Number.FloatToIntBits(v));
         }
 
         /// <summary>
-        /// Decodes a previously encoded {@code float}. </summary>
+        /// Decodes a previously encoded <see cref="float"/>.
+        /// </summary>
         public static float BytesRefToFloat(BytesRef b)
         {
             return Number.IntBitsToFloat(IntAssociationFacetField.BytesRefToInt(b));

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/44958102/src/Lucene.Net.Facet/Taxonomy/FloatTaxonomyFacets.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/FloatTaxonomyFacets.cs b/src/Lucene.Net.Facet/Taxonomy/FloatTaxonomyFacets.cs
index 27c8eff..70dffb4 100644
--- a/src/Lucene.Net.Facet/Taxonomy/FloatTaxonomyFacets.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/FloatTaxonomyFacets.cs
@@ -25,7 +25,7 @@ namespace Lucene.Net.Facet.Taxonomy
 
     /// <summary>
     /// Base class for all taxonomy-based facets that aggregate
-    ///  to a per-ords float[]. 
+    /// to a per-ords <see cref="float[]"/>. 
     /// </summary>
     public abstract class FloatTaxonomyFacets : TaxonomyFacets
     {
@@ -34,7 +34,8 @@ namespace Lucene.Net.Facet.Taxonomy
         protected readonly float[] values;
 
         /// <summary>
-        /// Sole constructor. </summary>
+        /// Sole constructor.
+        /// </summary>
         protected internal FloatTaxonomyFacets(string indexFieldName, TaxonomyReader taxoReader, FacetsConfig config)
             : base(indexFieldName, taxoReader, config)
         {
@@ -42,7 +43,8 @@ namespace Lucene.Net.Facet.Taxonomy
         }
 
         /// <summary>
-        /// Rolls up any single-valued hierarchical dimensions. </summary>
+        /// Rolls up any single-valued hierarchical dimensions.
+        /// </summary>
         protected virtual void Rollup()
         {
             // Rollup any necessary dims:

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/44958102/src/Lucene.Net.Facet/Taxonomy/IntAssociationFacetField.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/IntAssociationFacetField.cs b/src/Lucene.Net.Facet/Taxonomy/IntAssociationFacetField.cs
index e7b56d7..3cdf528 100644
--- a/src/Lucene.Net.Facet/Taxonomy/IntAssociationFacetField.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/IntAssociationFacetField.cs
@@ -23,18 +23,17 @@ namespace Lucene.Net.Facet.Taxonomy
     using Document = Lucene.Net.Documents.Document;
 
     /// <summary>
-    /// Add an instance of this to your <seealso cref="Document"/> to add
-    ///  a facet label associated with an int.  Use {@link
-    ///  TaxonomyFacetSumIntAssociations} to aggregate int values
-    ///  per facet label at search time.
+    /// Add an instance of this to your <see cref="Document"/> to add
+    /// a facet label associated with an int.  Use <see cref="TaxonomyFacetSumIntAssociations"/>
+    /// to aggregate int values per facet label at search time.
     /// 
     ///  @lucene.experimental 
     /// </summary>
     public class IntAssociationFacetField : AssociationFacetField
     {
         /// <summary>
-        /// Creates this from {@code dim} and {@code path} and an
-        ///  int association 
+        /// Creates this from <paramref name="dim"/> and <paramref name="path"/> and an
+        /// int association 
         /// </summary>
         public IntAssociationFacetField(int assoc, string dim, params string[] path)
             : base(IntToBytesRef(assoc), dim, path)
@@ -42,8 +41,8 @@ namespace Lucene.Net.Facet.Taxonomy
         }
 
         /// <summary>
-        /// Encodes an {@code int} as a 4-byte <seealso cref="BytesRef"/>,
-        ///  big-endian. 
+        /// Encodes an <see cref="int"/> as a 4-byte <see cref="BytesRef"/>,
+        /// big-endian. 
         /// </summary>
         public static BytesRef IntToBytesRef(int v)
         {
@@ -58,7 +57,8 @@ namespace Lucene.Net.Facet.Taxonomy
         }
 
         /// <summary>
-        /// Decodes a previously encoded {@code int}. </summary>
+        /// Decodes a previously encoded <see cref="int"/>.
+        /// </summary>
         public static int BytesRefToInt(BytesRef b)
         {
             return ((b.Bytes[b.Offset] & 0xFF) << 24) | ((b.Bytes[b.Offset + 1] & 0xFF) << 16) | 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/44958102/src/Lucene.Net.Facet/Taxonomy/IntTaxonomyFacets.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/IntTaxonomyFacets.cs b/src/Lucene.Net.Facet/Taxonomy/IntTaxonomyFacets.cs
index 2c4e533..60b59c9 100644
--- a/src/Lucene.Net.Facet/Taxonomy/IntTaxonomyFacets.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/IntTaxonomyFacets.cs
@@ -24,7 +24,7 @@ namespace Lucene.Net.Facet.Taxonomy
 
     /// <summary>
     /// Base class for all taxonomy-based facets that aggregate
-    ///  to a per-ords int[]. 
+    /// to a per-ords <see cref="int[]"/>. 
     /// </summary>
 
     public abstract class IntTaxonomyFacets : TaxonomyFacets
@@ -34,7 +34,8 @@ namespace Lucene.Net.Facet.Taxonomy
         protected internal readonly int[] values;
 
         /// <summary>
-        /// Sole constructor. </summary>
+        /// Sole constructor.
+        /// </summary>
         protected internal IntTaxonomyFacets(string indexFieldName, TaxonomyReader taxoReader, FacetsConfig config)
             : base(indexFieldName, taxoReader, config)
         {
@@ -42,7 +43,8 @@ namespace Lucene.Net.Facet.Taxonomy
         }
 
         /// <summary>
-        /// Rolls up any single-valued hierarchical dimensions. </summary>
+        /// Rolls up any single-valued hierarchical dimensions.
+        /// </summary>
         protected virtual void Rollup()
         {
             // Rollup any necessary dims:

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/44958102/src/Lucene.Net.Facet/Taxonomy/LRUHashMap.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/LRUHashMap.cs b/src/Lucene.Net.Facet/Taxonomy/LRUHashMap.cs
index 059f834..5ff77fb 100644
--- a/src/Lucene.Net.Facet/Taxonomy/LRUHashMap.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/LRUHashMap.cs
@@ -22,33 +22,17 @@ namespace Lucene.Net.Facet.Taxonomy
      */
 
     /// <summary>
-    /// LRUHashMap is an extension of Java's HashMap, which has a bounded size();
-    /// When it reaches that size, each time a new element is added, the least
+    /// <see cref="LRUHashMap{TKey, TValue}"/> is similar to of Java's HashMap, which has a bounded <see cref="Capacity"/>;
+    /// When it reaches that <see cref="Capacity"/>, each time a new element is added, the least
     /// recently used (LRU) entry is removed.
     /// <para>
-    /// Java makes it very easy to implement LRUHashMap - all its functionality is
-    /// already available from <seealso cref="java.util.LinkedHashMap"/>, and we just need to
-    /// configure that properly.
+    /// Unlike the Java Lucene implementation, this one is thread safe. Do note
+    /// that every time an element is read from <see cref="LRUHashMap{TKey, TValue}"/>,
+    /// a write operation also takes place to update the element's last access time.
+    /// This is because the LRU order needs to be remembered to determine which element
+    /// to evict when the <see cref="Capacity"/> is exceeded. 
     /// </para>
     /// <para>
-    /// Note that like HashMap, LRUHashMap is unsynchronized, and the user MUST
-    /// synchronize the access to it if used from several threads. Moreover, while
-    /// with HashMap this is only a concern if one of the threads is modifies the
-    /// map, with LURHashMap every read is a modification (because the LRU order
-    /// needs to be remembered) so proper synchronization is always necessary.
-    /// </para>
-    /// <para>
-    /// With the usual synchronization mechanisms available to the user, this
-    /// unfortunately means that LRUHashMap will probably perform sub-optimally under
-    /// heavy contention: while one thread uses the hash table (reads or writes), any
-    /// other thread will be blocked from using it - or even just starting to use it
-    /// (e.g., calculating the hash function). A more efficient approach would be not
-    /// to use LinkedHashMap at all, but rather to use a non-locking (as much as
-    /// possible) thread-safe solution, something along the lines of
-    /// java.util.concurrent.ConcurrentHashMap (though that particular class does not
-    /// support the additional LRU semantics, which will need to be added separately
-    /// using a concurrent linked list or additional storage of timestamps (in an
-    /// array or inside the entry objects), or whatever).
     /// 
     /// @lucene.experimental
     /// </para>
@@ -74,6 +58,17 @@ namespace Lucene.Net.Facet.Taxonomy
             this.cache = new Dictionary<TKey, CacheDataObject>(capacity);
         }
 
+        /// <summary>
+        /// allows changing the map's maximal number of elements
+        /// which was defined at construction time.
+        /// <para>
+        /// Note that if the map is already larger than maxSize, the current 
+        /// implementation does not shrink it (by removing the oldest elements);
+        /// Rather, the map remains in its current size as new elements are
+        /// added, and will only start shrinking (until settling again on the
+        /// given <see cref="Capacity"/>) if existing elements are explicitly deleted.
+        /// </para>
+        /// </summary>
         public virtual int Capacity
         {
             get { return capacity; }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/44958102/src/Lucene.Net.Facet/Taxonomy/OrdinalsReader.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/OrdinalsReader.cs b/src/Lucene.Net.Facet/Taxonomy/OrdinalsReader.cs
index c8e4843..3223b6a 100644
--- a/src/Lucene.Net.Facet/Taxonomy/OrdinalsReader.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/OrdinalsReader.cs
@@ -23,16 +23,16 @@
     /// <summary>
     /// Provides per-document ordinals. 
     /// </summary>
-
     public abstract class OrdinalsReader
     {
         /// <summary>
-        /// Returns ordinals for documents in one segment. </summary>
+        /// Returns ordinals for documents in one segment.
+        /// </summary>
         public abstract class OrdinalsSegmentReader
         {
             /// <summary>
-            /// Get the ordinals for this document.  ordinals.offset
-            ///  must always be 0! 
+            /// Get the ordinals for this document. The <paramref name="ordinals"/>.<see cref="IntsRef.Offset"/>
+            /// must always be 0! 
             /// </summary>
             public abstract void Get(int doc, IntsRef ordinals);
 
@@ -57,8 +57,8 @@
         public abstract OrdinalsSegmentReader GetReader(AtomicReaderContext context);
 
         /// <summary>
-        /// Returns the indexed field name this {@code
-        ///  OrdinalsReader} is reading from. 
+        /// Returns the indexed field name this <see cref="OrdinalsReader"/>
+        /// is reading from. 
         /// </summary>
         public abstract string IndexFieldName { get; }
     }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/44958102/src/Lucene.Net.Facet/Taxonomy/ParallelTaxonomyArrays.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/ParallelTaxonomyArrays.cs b/src/Lucene.Net.Facet/Taxonomy/ParallelTaxonomyArrays.cs
index 1b51568..297c5c2 100644
--- a/src/Lucene.Net.Facet/Taxonomy/ParallelTaxonomyArrays.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/ParallelTaxonomyArrays.cs
@@ -19,18 +19,18 @@
 
     /// <summary>
     /// Returns 3 arrays for traversing the taxonomy:
-    /// <ul>
-    /// <li>{@code parents}: {@code parents[i]} denotes the parent of category
-    /// ordinal {@code i}.</li>
-    /// <li>{@code children}: {@code children[i]} denotes a child of category ordinal
-    /// {@code i}.</li>
-    /// <li>{@code siblings}: {@code siblings[i]} denotes the sibling of category
-    /// ordinal {@code i}.</li>
-    /// </ul>
+    /// <list type="bullet">
+    /// <item> <see cref="Parents"/>: <c>Parents[i]</c> denotes the parent of category
+    /// ordinal <c>i</c>.</item>
+    /// <item> <see cref="Children"/>: <c>Children[i]</c> denotes a child of category ordinal
+    /// <c>i</c>.</item>
+    /// <item> <see cref="Siblings"/>: <c>Siblings[i]</c> denotes the sibling of category
+    /// ordinal <c>i</c>.</item>
+    /// </list>
     /// 
-    /// To traverse the taxonomy tree, you typically start with {@code children[0]}
+    /// To traverse the taxonomy tree, you typically start with <c>Children[0]</c>
     /// (ordinal 0 is reserved for ROOT), and then depends if you want to do DFS or
-    /// BFS, you call {@code children[children[0]]} or {@code siblings[children[0]]}
+    /// BFS, you call <c>Children[Children[0]]</c> or <c>Siblings[Children[0]]</c>
     /// and so forth, respectively.
     /// 
     /// <para>
@@ -43,26 +43,27 @@
     public abstract class ParallelTaxonomyArrays
     {
         /// <summary>
-        /// Sole constructor. </summary>
+        /// Sole constructor.
+        /// </summary>
         public ParallelTaxonomyArrays()
         {
         }
 
         /// <summary>
-        /// Returns the parents array, where {@code parents[i]} denotes the parent of
-        /// category ordinal {@code i}.
+        /// Returns the parents array, where <c>Parents[i]</c> denotes the parent of
+        /// category ordinal <c>i</c>.
         /// </summary>
         public abstract int[] Parents { get; }
 
         /// <summary>
-        /// Returns the children array, where {@code children[i]} denotes a child of
-        /// category ordinal {@code i}.
+        /// Returns the children array, where <c>Children[i]</c> denotes a child of
+        /// category ordinal <c>i</c>.
         /// </summary>
         public abstract int[] Children { get; }
 
         /// <summary>
-        /// Returns the siblings array, where {@code siblings[i]} denotes the sibling
-        /// of category ordinal {@code i}.
+        /// Returns the siblings array, where <c>Siblings[i]</c> denotes the sibling
+        /// of category ordinal <c>i</c>.
         /// </summary>
         public abstract int[] Siblings { get; }
     }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/44958102/src/Lucene.Net.Facet/Taxonomy/PrintTaxonomyStats.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/PrintTaxonomyStats.cs b/src/Lucene.Net.Facet/Taxonomy/PrintTaxonomyStats.cs
index 601e5d8..1f94b86 100644
--- a/src/Lucene.Net.Facet/Taxonomy/PrintTaxonomyStats.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/PrintTaxonomyStats.cs
@@ -26,19 +26,22 @@ namespace Lucene.Net.Facet.Taxonomy
     using FSDirectory = Lucene.Net.Store.FSDirectory;
 
     /// <summary>
-    /// Prints how many ords are under each dimension. </summary>
+    /// Prints how many ords are under each dimension. 
+    /// </summary>
 
     // java -cp ../build/core/classes/java:../build/facet/classes/java org.apache.lucene.facet.util.PrintTaxonomyStats -printTree /s2/scratch/indices/wikibig.trunk.noparents.facets.Lucene41.nd1M/facets
     public class PrintTaxonomyStats
     {
         /// <summary>
-        /// Sole constructor. </summary>
+        /// Sole constructor.
+        /// </summary>
         public PrintTaxonomyStats()
         {
         }
 
         /// <summary>
-        /// Command-line tool. </summary>
+        /// Command-line tool.
+        /// </summary>
         public static void Main(string[] args)
         {
             bool printTree = false;
@@ -56,6 +59,7 @@ namespace Lucene.Net.Facet.Taxonomy
             }
             if (args.Length != (printTree ? 2 : 1))
             {
+                // LUCENENET TODO: Usage depends on wrapping this into a console application assembly.
                 Console.WriteLine("\nUsage: java -classpath ... org.apache.lucene.facet.util.PrintTaxonomyStats [-printTree] /path/to/taxononmy/index\n");
                 Environment.Exit(1);
             }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/44958102/src/Lucene.Net.Facet/Taxonomy/SearcherTaxonomyManager.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/SearcherTaxonomyManager.cs b/src/Lucene.Net.Facet/Taxonomy/SearcherTaxonomyManager.cs
index 2c8edb3..8fb75d8 100644
--- a/src/Lucene.Net.Facet/Taxonomy/SearcherTaxonomyManager.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/SearcherTaxonomyManager.cs
@@ -32,32 +32,35 @@ namespace Lucene.Net.Facet.Taxonomy
     using SearcherManager = Lucene.Net.Search.SearcherManager;
 
     /// <summary>
-    /// Manages near-real-time reopen of both an IndexSearcher
-    /// and a TaxonomyReader.
+    /// Manages near-real-time reopen of both an <see cref="IndexSearcher"/>
+    /// and a <see cref="TaxonomyReader"/>.
     /// 
-    /// <para><b>NOTE</b>: If you call {@link
-    /// DirectoryTaxonomyWriter#replaceTaxonomy} then you must
-    /// open a new {@code SearcherTaxonomyManager} afterwards.
+    /// <para>
+    /// <b>NOTE</b>: If you call <see cref="DirectoryTaxonomyWriter.ReplaceTaxonomy"/>
+    /// then you must open a new <see cref="SearcherTaxonomyManager"/> afterwards.
     /// </para>
     /// </summary>
     public class SearcherTaxonomyManager : ReferenceManager<SearcherTaxonomyManager.SearcherAndTaxonomy>
     {
         /// <summary>
-        /// Holds a matched pair of <seealso cref="IndexSearcher"/> and
-        ///  <seealso cref="Taxonomy.TaxonomyReader"/> 
+        /// Holds a matched pair of <see cref="IndexSearcher"/> and
+        /// <see cref="Taxonomy.TaxonomyReader"/> 
         /// </summary>
         public class SearcherAndTaxonomy
         {
             /// <summary>
-            /// Point-in-time <seealso cref="IndexSearcher"/>. </summary>
+            /// Point-in-time <see cref="IndexSearcher"/>.
+            /// </summary>
             public IndexSearcher Searcher { get; private set; }
 
             /// <summary>
-            /// Matching point-in-time <seealso cref="DirectoryTaxonomyReader"/>. </summary>
+            /// Matching point-in-time <see cref="DirectoryTaxonomyReader"/>.
+            /// </summary>
             public DirectoryTaxonomyReader TaxonomyReader { get; private set; }
 
             /// <summary>
-            /// Create a SearcherAndTaxonomy </summary>
+            /// Create a <see cref="SearcherAndTaxonomy"/>
+            /// </summary>
             public SearcherAndTaxonomy(IndexSearcher searcher, DirectoryTaxonomyReader taxonomyReader)
             {
                 this.Searcher = searcher;
@@ -71,7 +74,7 @@ namespace Lucene.Net.Facet.Taxonomy
 
         /// <summary>
         /// Creates near-real-time searcher and taxonomy reader
-        ///  from the corresponding writers. 
+        /// from the corresponding writers. 
         /// </summary>
         public SearcherTaxonomyManager(IndexWriter writer, bool applyAllDeletes, 
             SearcherFactory searcherFactory, DirectoryTaxonomyWriter taxoWriter)
@@ -93,8 +96,8 @@ namespace Lucene.Net.Facet.Taxonomy
         /// 
         /// <para>
         /// <b>NOTE:</b> you should only use this constructor if you commit and call
-        /// <seealso cref="#maybeRefresh()"/> in the same thread. Otherwise it could lead to an
-        /// unsync'd <seealso cref="IndexSearcher"/> and <seealso cref="TaxonomyReader"/> pair.
+        /// <see cref="Index.ReaderManager.MaybeRefresh()"/> in the same thread. Otherwise it could lead to an
+        /// unsync'd <see cref="IndexSearcher"/> and <see cref="TaxonomyReader"/> pair.
         /// </para>
         /// </summary>
         public SearcherTaxonomyManager(Store.Directory indexDir, Store.Directory taxoDir, SearcherFactory searcherFactory)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/44958102/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetCounts.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetCounts.cs b/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetCounts.cs
index b86c924..aa4acac 100644
--- a/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetCounts.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetCounts.cs
@@ -25,9 +25,8 @@ namespace Lucene.Net.Facet.Taxonomy
     using MatchingDocs = FacetsCollector.MatchingDocs;
 
     /// <summary>
-    /// Reads from any <seealso cref="OrdinalsReader"/>; use {@link
-    ///  FastTaxonomyFacetCounts} if you are using the
-    ///  default encoding from <seealso cref="BinaryDocValues"/>.
+    /// Reads from any <see cref="OrdinalsReader"/>; use <see cref="FastTaxonomyFacetCounts"/>
+    /// if you are using the default encoding from <see cref="BinaryDocValues"/>.
     /// 
     /// @lucene.experimental 
     /// </summary>
@@ -36,10 +35,9 @@ namespace Lucene.Net.Facet.Taxonomy
         private readonly OrdinalsReader ordinalsReader;
 
         /// <summary>
-        /// Create {@code TaxonomyFacetCounts}, which also
-        ///  counts all facet labels.  Use this for a non-default
-        ///  <seealso cref="OrdinalsReader"/>; otherwise use {@link
-        ///  FastTaxonomyFacetCounts}. 
+        /// Create <see cref="TaxonomyFacetCounts"/>, which also
+        /// counts all facet labels.  Use this for a non-default
+        /// <see cref="OrdinalsReader"/>; otherwise use <see cref="FastTaxonomyFacetCounts"/>. 
         /// </summary>
         public TaxonomyFacetCounts(OrdinalsReader ordinalsReader, TaxonomyReader taxoReader, FacetsConfig config, FacetsCollector fc)
             : base(ordinalsReader.IndexFieldName, taxoReader, config)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/44958102/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetSumFloatAssociations.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetSumFloatAssociations.cs b/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetSumFloatAssociations.cs
index e30cef2..242466d 100644
--- a/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetSumFloatAssociations.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetSumFloatAssociations.cs
@@ -27,16 +27,16 @@ namespace Lucene.Net.Facet.Taxonomy
 
     /// <summary>
     /// Aggregates sum of int values previously indexed with
-    ///  <seealso cref="FloatAssociationFacetField"/>, assuming the default
-    ///  encoding.
+    /// <see cref="FloatAssociationFacetField"/>, assuming the default
+    /// encoding.
     /// 
     ///  @lucene.experimental 
     /// </summary>
     public class TaxonomyFacetSumFloatAssociations : FloatTaxonomyFacets
     {
         /// <summary>
-        /// Create {@code TaxonomyFacetSumFloatAssociations} against
-        ///  the default index field. 
+        /// Create <see cref="TaxonomyFacetSumFloatAssociations"/> against
+        /// the default index field. 
         /// </summary>
         public TaxonomyFacetSumFloatAssociations(TaxonomyReader taxoReader, FacetsConfig config, FacetsCollector fc)
             : this(FacetsConfig.DEFAULT_INDEX_FIELD_NAME, taxoReader, config, fc)
@@ -44,8 +44,8 @@ namespace Lucene.Net.Facet.Taxonomy
         }
 
         /// <summary>
-        /// Create {@code TaxonomyFacetSumFloatAssociations} against
-        ///  the specified index field. 
+        /// Create <see cref="TaxonomyFacetSumFloatAssociations"/> against
+        /// the specified index field. 
         /// </summary>
         public TaxonomyFacetSumFloatAssociations(string indexFieldName, TaxonomyReader taxoReader, FacetsConfig config, FacetsCollector fc)
             : base(indexFieldName, taxoReader, config)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/44958102/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetSumIntAssociations.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetSumIntAssociations.cs b/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetSumIntAssociations.cs
index 7ff982b..07b78b0 100644
--- a/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetSumIntAssociations.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetSumIntAssociations.cs
@@ -26,16 +26,16 @@ namespace Lucene.Net.Facet.Taxonomy
 
     /// <summary>
     /// Aggregates sum of int values previously indexed with
-    ///  <seealso cref="IntAssociationFacetField"/>, assuming the default
-    ///  encoding.
+    /// <see cref="IntAssociationFacetField"/>, assuming the default
+    /// encoding.
     /// 
     ///  @lucene.experimental 
     /// </summary>
     public class TaxonomyFacetSumIntAssociations : IntTaxonomyFacets
     {
         /// <summary>
-        /// Create {@code TaxonomyFacetSumIntAssociations} against
-        ///  the default index field. 
+        /// Create <see cref="TaxonomyFacetSumIntAssociations"/> against
+        /// the default index field. 
         /// </summary>
         public TaxonomyFacetSumIntAssociations(TaxonomyReader taxoReader, FacetsConfig config, FacetsCollector fc)
             : this(FacetsConfig.DEFAULT_INDEX_FIELD_NAME, taxoReader, config, fc)
@@ -43,8 +43,8 @@ namespace Lucene.Net.Facet.Taxonomy
         }
 
         /// <summary>
-        /// Create {@code TaxonomyFacetSumIntAssociations} against
-        ///  the specified index field. 
+        /// Create <see cref="TaxonomyFacetSumIntAssociations"/> against
+        /// the specified index field. 
         /// </summary>
         public TaxonomyFacetSumIntAssociations(string indexFieldName, TaxonomyReader taxoReader, FacetsConfig config, FacetsCollector fc)
             : base(indexFieldName, taxoReader, config)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/44958102/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetSumValueSource.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetSumValueSource.cs b/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetSumValueSource.cs
index ffe18df..c5e5cb5 100644
--- a/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetSumValueSource.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetSumValueSource.cs
@@ -33,8 +33,8 @@ namespace Lucene.Net.Facet.Taxonomy
     using Weight = Lucene.Net.Search.Weight;
 
     /// <summary>
-    /// Aggregates sum of values from {@link
-    ///  FunctionValues#doubleVal}, for each facet label.
+    /// Aggregates sum of values from <see cref="FunctionValues.DoubleVal"/>, 
+    /// for each facet label.
     /// 
     ///  @lucene.experimental 
     /// </summary>
@@ -44,10 +44,9 @@ namespace Lucene.Net.Facet.Taxonomy
 
         /// <summary>
         /// Aggreggates float facet values from the provided
-        ///  <seealso cref="ValueSource"/>, pulling ordinals using {@link
-        ///  DocValuesOrdinalsReader} against the default indexed
-        ///  facet field {@link
-        ///  FacetsConfig#DEFAULT_INDEX_FIELD_NAME}. 
+        /// <see cref="ValueSource"/>, pulling ordinals using <see cref="DocValuesOrdinalsReader"/>
+        /// against the default indexed
+        /// facet field <see cref="FacetsConfig.DEFAULT_INDEX_FIELD_NAME"/>. 
         /// </summary>
         public TaxonomyFacetSumValueSource(TaxonomyReader taxoReader, FacetsConfig config,
             FacetsCollector fc, ValueSource valueSource)
@@ -58,8 +57,8 @@ namespace Lucene.Net.Facet.Taxonomy
 
         /// <summary>
         /// Aggreggates float facet values from the provided
-        ///  <seealso cref="ValueSource"/>, and pulls ordinals from the
-        ///  provided <seealso cref="OrdinalsReader"/>. 
+        /// <see cref="ValueSource"/>, and pulls ordinals from the
+        /// provided <see cref="OrdinalsReader"/>. 
         /// </summary>
         public TaxonomyFacetSumValueSource(OrdinalsReader ordinalsReader, TaxonomyReader taxoReader,
             FacetsConfig config, FacetsCollector fc, ValueSource valueSource)
@@ -158,15 +157,16 @@ namespace Lucene.Net.Facet.Taxonomy
         }
 
         /// <summary>
-        /// <seealso cref="ValueSource"/> that returns the score for each
-        ///  hit; use this to aggregate the sum of all hit scores
-        ///  for each facet label.  
+        /// <see cref="ValueSource"/> that returns the score for each
+        /// hit; use this to aggregate the sum of all hit scores
+        /// for each facet label.  
         /// </summary>
         public class ScoreValueSource : ValueSource
         {
 
             /// <summary>
-            /// Sole constructor. </summary>
+            /// Sole constructor.
+            /// </summary>
             public ScoreValueSource()
             {
             }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/44958102/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacets.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacets.cs b/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacets.cs
index ef8dede..87ea6d0 100644
--- a/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacets.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacets.cs
@@ -25,7 +25,8 @@ namespace Lucene.Net.Facet.Taxonomy
     using DimConfig = Lucene.Net.Facet.FacetsConfig.DimConfig; // javadocs
 
     /// <summary>
-    /// Base class for all taxonomy-based facets impls. </summary>
+    /// Base class for all taxonomy-based facets impls.
+    /// </summary>
     public abstract class TaxonomyFacets : Facets
     {
         private static readonly IComparer<FacetResult> BY_VALUE_THEN_DIM = new ComparatorAnonymousInnerClassHelper();
@@ -54,26 +55,29 @@ namespace Lucene.Net.Facet.Taxonomy
         }
 
         /// <summary>
-        /// Index field name provided to the constructor. </summary>
+        /// Index field name provided to the constructor.
+        /// </summary>
         protected readonly string indexFieldName;
 
         /// <summary>
-        /// {@code TaxonomyReader} provided to the constructor. </summary>
+        /// <see cref="TaxonomyReader"/> provided to the constructor.
+        /// </summary>
         protected readonly TaxonomyReader taxoReader;
 
         /// <summary>
-        /// {@code FacetsConfig} provided to the constructor. </summary>
+        /// <see cref="FacetsConfig"/> provided to the constructor.
+        /// </summary>
         protected readonly FacetsConfig config;
 
         /// <summary>
         /// Maps parent ordinal to its child, or -1 if the parent
-        ///  is childless. 
+        /// is childless. 
         /// </summary>
         protected readonly int[] children;
 
         /// <summary>
         /// Maps an ordinal to its sibling, or -1 if there is no
-        ///  sibling. 
+        /// sibling. 
         /// </summary>
         protected readonly int[] siblings;
 
@@ -91,9 +95,9 @@ namespace Lucene.Net.Facet.Taxonomy
         }
 
         /// <summary>
-        /// Throws {@code IllegalArgumentException} if the
-        ///  dimension is not recognized.  Otherwise, returns the
-        ///  <seealso cref="DimConfig"/> for this dimension. 
+        /// Throws <see cref="ArgumentException"/> if the
+        /// dimension is not recognized.  Otherwise, returns the
+        /// <see cref="DimConfig"/> for this dimension. 
         /// </summary>
         protected internal virtual DimConfig VerifyDim(string dim)
         {