lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From synhers...@apache.org
Subject [39/46] lucenenet git commit: Facet: Updated documentation
Date Tue, 04 Oct 2016 20:02:09 GMT
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/44958102/src/Lucene.Net.Facet/Taxonomy/TaxonomyReader.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/TaxonomyReader.cs b/src/Lucene.Net.Facet/Taxonomy/TaxonomyReader.cs
index db56dc2..4cf132d 100644
--- a/src/Lucene.Net.Facet/Taxonomy/TaxonomyReader.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/TaxonomyReader.cs
@@ -28,32 +28,37 @@ namespace Lucene.Net.Facet.Taxonomy
     /// <summary>
     /// TaxonomyReader is the read-only interface with which the faceted-search
     /// library uses the taxonomy during search time.
-    /// <P>
+    /// <para>
     /// A TaxonomyReader holds a list of categories. Each category has a serial
     /// number which we call an "ordinal", and a hierarchical "path" name:
-    /// <UL>
-    /// <LI>
+    /// <list type="bullet">
+    /// <item>
     /// The ordinal is an integer that starts at 0 for the first category (which is
     /// always the root category), and grows contiguously as more categories are
     /// added; Note that once a category is added, it can never be deleted.
-    /// <LI>
+    /// </item>
+    /// <item>
     /// The path is a CategoryPath object specifying the category's position in the
     /// hierarchy.
-    /// </UL>
-    /// <B>Notes about concurrent access to the taxonomy:</B>
-    /// <P>
+    /// </item>
+    /// </list>
+    /// </para>
+    /// <b>Notes about concurrent access to the taxonomy:</b>
+    /// <para>
     /// An implementation must allow multiple readers to be active concurrently
     /// with a single writer. Readers follow so-called "point in time" semantics,
     /// i.e., a TaxonomyReader object will only see taxonomy entries which were
     /// available at the time it was created. What the writer writes is only
-    /// available to (new) readers after the writer's commit() is called.
-    /// <P>
+    /// available to (new) readers after the writer's <see cref="Index.IndexWriter.Commit()"/>
is called.
+    /// </para>
+    /// <para>
     /// In faceted search, two separate indices are used: the main Lucene index,
     /// and the taxonomy. Because the main index refers to the categories listed
     /// in the taxonomy, it is important to open the taxonomy *after* opening the
-    /// main index, and it is also necessary to reopen() the taxonomy after
-    /// reopen()ing the main index.
-    /// <P>
+    /// main index, and it is also necessary to Reopen() the taxonomy after
+    /// Reopen()ing the main index.
+    /// </para>
+    /// <para>
     /// This order is important, otherwise it would be possible for the main index
     /// to refer to a category which is not yet visible in the old snapshot of
     /// the taxonomy. Note that it is indeed fine for the the taxonomy to be opened
@@ -61,13 +66,15 @@ namespace Lucene.Net.Facet.Taxonomy
     /// a category is added to the taxonomy, it can never be changed or deleted,
     /// so there is no danger that a "too new" taxonomy not being consistent with
     /// an older index.
+    /// </para>
     /// 
     /// @lucene.experimental
     /// </summary>
     public abstract class TaxonomyReader
     {
         /// <summary>
-        /// An iterator over a category's children. </summary>
+        /// An iterator over a category's children.
+        /// </summary>
         public class ChildrenIterator
         {
             private readonly int[] siblings;
@@ -80,7 +87,7 @@ namespace Lucene.Net.Facet.Taxonomy
             }
 
             /// <summary>
-            /// Return the next child ordinal, or <seealso cref="TaxonomyReader#INVALID_ORDINAL"/>
+            /// Return the next child ordinal, or <see cref="TaxonomyReader.INVALID_ORDINAL"/>
             /// if no more children.
             /// </summary>
             public virtual int Next()
@@ -95,35 +102,36 @@ namespace Lucene.Net.Facet.Taxonomy
         }
 
         /// <summary>
-        /// Sole constructor. </summary>
+        /// Sole constructor.
+        /// </summary>
         public TaxonomyReader()
         {
         }
 
         /// <summary>
         /// The root category (the category with the empty path) always has the ordinal
-        /// 0, to which we give a name ROOT_ORDINAL. <seealso cref="#getOrdinal(FacetLabel)"/>
-        /// of an empty path will always return {@code ROOT_ORDINAL}, and
-        /// <seealso cref="#getPath(int)"/> with {@code ROOT_ORDINAL} will return the
empty path.
+        /// 0, to which we give a name ROOT_ORDINAL. <see cref="GetOrdinal(FacetLabel)"/>
+        /// of an empty path will always return <see cref="ROOT_ORDINAL"/>, and
+        /// <see cref="GetPath(int)"/> with <see cref="ROOT_ORDINAL"/> will return
the empty path.
         /// </summary>
         public const int ROOT_ORDINAL = 0;
 
         /// <summary>
         /// Ordinals are always non-negative, so a negative ordinal can be used to
-        /// signify an error. Methods here return INVALID_ORDINAL (-1) in this case.
+        /// signify an error. Methods here return <see cref="INVALID_ORDINAL"/> (-1)
in this case.
         /// </summary>
         public const int INVALID_ORDINAL = -1;
 
         /// <summary>
         /// If the taxonomy has changed since the provided reader was opened, open and
-        /// return a new <seealso cref="TaxonomyReader"/>; else, return {@code null}.
The new
-        /// reader, if not {@code null}, will be the same type of reader as the one
+        /// return a new <see cref="TaxonomyReader"/>; else, return <c>null</c>.
The new
+        /// reader, if not <c>null</c>, will be the same type of reader as the
one
         /// given to this method.
         /// 
         /// <para>
         /// This method is typically far less costly than opening a fully new
-        /// <seealso cref="TaxonomyReader"/> as it shares resources with the provided
-        /// <seealso cref="TaxonomyReader"/>, when possible.
+        /// <see cref="TaxonomyReader"/> as it shares resources with the provided
+        /// <see cref="TaxonomyReader"/>, when possible.
         /// </para>
         /// </summary>
         public static T OpenIfChanged<T>(T oldTaxoReader) where T : TaxonomyReader
@@ -145,14 +153,14 @@ namespace Lucene.Net.Facet.Taxonomy
         protected internal abstract void DoClose();
 
         /// <summary>
-        /// Implements the actual opening of a new <seealso cref="TaxonomyReader"/>
instance if
+        /// Implements the actual opening of a new <see cref="TaxonomyReader"/> instance
if
         /// the taxonomy has changed.
         /// </summary>
-        /// <seealso cref= #openIfChanged(TaxonomyReader) </seealso>
+        /// <see cref= #openIfChanged(TaxonomyReader) </seealso>
         protected abstract TaxonomyReader DoOpenIfChanged();
 
         /// <summary>
-        /// Throws <seealso cref="AlreadyClosedException"/> if this IndexReader is
closed
+        /// Throws <see cref="AlreadyClosedException"/> if this <see cref="IndexReader"/>
is disposed
         /// </summary>
         protected void EnsureOpen()
         {
@@ -211,13 +219,14 @@ namespace Lucene.Net.Facet.Taxonomy
         }
 
         /// <summary>
-        /// Returns a <seealso cref="ParallelTaxonomyArrays"/> object which can be
used to
+        /// Returns a <see cref="ParallelTaxonomyArrays"/> object which can be used
to
         /// efficiently traverse the taxonomy tree.
         /// </summary>
         public abstract ParallelTaxonomyArrays ParallelTaxonomyArrays { get; }
 
         /// <summary>
-        /// Returns an iterator over the children of the given ordinal. </summary>
+        /// Returns an iterator over the children of the given ordinal.
+        /// </summary>
         public virtual ChildrenIterator GetChildren(int ordinal)
         {
             ParallelTaxonomyArrays arrays = ParallelTaxonomyArrays;
@@ -228,7 +237,7 @@ namespace Lucene.Net.Facet.Taxonomy
         /// <summary>
         /// Retrieve user committed data.
         /// </summary>
-        /// <seealso cref= TaxonomyWriter#setCommitData(Map) </seealso>
+        /// <seealso cref="ITaxonomyWriter.CommitData"/>
         public abstract IDictionary<string, string> CommitUserData { get; }
 
         /// <summary>
@@ -237,12 +246,13 @@ namespace Lucene.Net.Facet.Taxonomy
         /// categories are added (note that once a category is added, it can never be
         /// deleted).
         /// </summary>
-        /// <returns> the category's ordinal or <seealso cref="#INVALID_ORDINAL"/>
if the category
-        ///         wasn't foun. </returns>
+        /// <returns> the category's ordinal or <see cref="INVALID_ORDINAL"/>
if the category
+        ///         wasn't found. </returns>
         public abstract int GetOrdinal(FacetLabel categoryPath);
 
         /// <summary>
-        /// Returns ordinal for the dim + path. </summary>
+        /// Returns ordinal for the dim + path.
+        /// </summary>
         public virtual int GetOrdinal(string dim, string[] path)
         {
             string[] fullPath = new string[path.Length + 1];
@@ -252,11 +262,13 @@ namespace Lucene.Net.Facet.Taxonomy
         }
 
         /// <summary>
-        /// Returns the path name of the category with the given ordinal. </summary>
+        /// Returns the path name of the category with the given ordinal.
+        /// </summary>
         public abstract FacetLabel GetPath(int ordinal);
 
         /// <summary>
-        /// Returns the current refCount for this taxonomy reader. </summary>
+        /// Returns the current refCount for this taxonomy reader.
+        /// </summary>
         public int RefCount
         {
             get
@@ -278,8 +290,8 @@ namespace Lucene.Net.Facet.Taxonomy
         /// Expert: increments the refCount of this TaxonomyReader instance. RefCounts
         /// can be used to determine when a taxonomy reader can be closed safely, i.e.
         /// as soon as there are no more references. Be sure to always call a
-        /// corresponding decRef(), in a finally clause; otherwise the reader may never
-        /// be closed.
+        /// corresponding <see cref="DecRef"/>, in a finally clause; otherwise the
reader may never
+        /// be disposed.
         /// </summary>
         public void IncRef()
         {
@@ -289,8 +301,8 @@ namespace Lucene.Net.Facet.Taxonomy
 
         /// <summary>
         /// Expert: increments the refCount of this TaxonomyReader
-        ///  instance only if it has not been closed yet.  Returns
-        ///  true on success. 
+        /// instance only if it has not been closed yet.  Returns
+        /// <c>true</c> on success. 
         /// </summary>
         public bool TryIncRef()
         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/44958102/src/Lucene.Net.Facet/Taxonomy/TaxonomyWriter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/TaxonomyWriter.cs b/src/Lucene.Net.Facet/Taxonomy/TaxonomyWriter.cs
index fdec22f..94f62a1 100644
--- a/src/Lucene.Net.Facet/Taxonomy/TaxonomyWriter.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/TaxonomyWriter.cs
@@ -23,17 +23,19 @@ namespace Lucene.Net.Facet.Taxonomy
     using TwoPhaseCommit = Lucene.Net.Index.TwoPhaseCommit;
 
     /// <summary>
-    /// ITaxonomyWriter is the interface which the faceted-search library uses
+    /// <see cref="ITaxonomyWriter"/> is the interface which the faceted-search library
uses
     /// to dynamically build the taxonomy at indexing time.
-    /// <P>
+    /// <para>
     /// Notes about concurrent access to the taxonomy:
-    /// <P>
+    /// </para>
+    /// <para>
     /// An implementation must allow multiple readers and a single writer to be
     /// active concurrently. Readers follow so-called "point in time" semantics,
     /// i.e., a reader object will only see taxonomy entries which were available
     /// at the time it was created. What the writer writes is only available to
-    /// (new) readers after the writer's commit() is called.
-    /// <P>
+    /// (new) readers after the writer's <see cref="Index.IndexWriter.Commit"/> is
called.
+    /// </para>
+    /// <para>
     /// Faceted search keeps two indices - namely Lucene's main index, and this
     /// taxonomy index. When one or more readers are active concurrently with the
     /// writer, care must be taken to avoid an inconsistency between the state of
@@ -41,24 +43,25 @@ namespace Lucene.Net.Facet.Taxonomy
     /// be committed to disk *before* the main index, because the main index
     /// refers to categories listed in the taxonomy.
     /// Such control can best be achieved by turning off the main index's
-    /// "autocommit" feature, and explicitly calling commit() for both indices
+    /// "autocommit" feature, and explicitly calling <see cref="Index.IndexWriter.Commit"/>
for both indices
     /// (first for the taxonomy, then for the main index).
     /// In old versions of Lucene (2.2 or earlier), when autocommit could not be
     /// turned off, a more complicated solution needs to be used. E.g., use
     /// some sort of (possibly inter-process) locking to ensure that a reader
     /// is being opened only right after both indices have been flushed (and
     /// before anything else is written to them).
+    /// </para>
     /// 
     /// @lucene.experimental
     /// </summary>
     public interface ITaxonomyWriter : IDisposable, TwoPhaseCommit
     {
         /// <summary>
-        /// addCategory() adds a category with a given path name to the taxonomy,
+        /// <see cref="AddCategory"/> adds a category with a given path name to the
taxonomy,
         /// and returns its ordinal. If the category was already present in
         /// the taxonomy, its existing ordinal is returned.
         /// <P>
-        /// Before adding a category, addCategory() makes sure that all its
+        /// Before adding a category, <see cref="AddCategory"/> makes sure that all
its
         /// ancestor categories exist in the taxonomy as well. As result, the
         /// ordinal of a category is guaranteed to be smaller then the ordinal of
         /// any of its descendants. 
@@ -66,37 +69,42 @@ namespace Lucene.Net.Facet.Taxonomy
         int AddCategory(FacetLabel categoryPath);
 
         /// <summary>
-        /// getParent() returns the ordinal of the parent category of the category
+        /// <see cref="GetParent"/> returns the ordinal of the parent category of the
category
         /// with the given ordinal.
-        /// <P>
+        /// <para>
         /// When a category is specified as a path name, finding the path of its
         /// parent is as trivial as dropping the last component of the path.
-        /// getParent() is functionally equivalent to calling getPath() on the
+        /// <see cref="GetParent"/> is functionally equivalent to calling <see cref="TaxonomyReader.GetPath"/>
on the
         /// given ordinal, dropping the last component of the path, and then calling
-        /// getOrdinal() to get an ordinal back. 
-        /// <P>
-        /// If the given ordinal is the ROOT_ORDINAL, an INVALID_ORDINAL is returned.
-        /// If the given ordinal is a top-level category, the ROOT_ORDINAL is returned.
+        /// <see cref="TaxonomyReader.GetOrdinal"/> to get an ordinal back.
+        /// </para>
+        /// <para>
+        /// If the given ordinal is the <see cref="TaxonomyReader.ROOT_ORDINAL"/>,
an 
+        /// <see cref="TaxonomyReader.INVALID_ORDINAL"/> is returned.
+        /// If the given ordinal is a top-level category, the 
+        /// <see cref="TaxonomyReader.ROOT_ORDINAL"/> is returned.
         /// If an invalid ordinal is given (negative or beyond the last available
-        /// ordinal), an ArrayIndexOutOfBoundsException is thrown. However, it is
-        /// expected that getParent will only be called for ordinals which are
+        /// ordinal), an <see cref="IndexOutOfRangeException"/> is thrown. However,
it is
+        /// expected that <see cref="GetParent"/> will only be called for ordinals
which are
         /// already known to be in the taxonomy.
-        /// TODO (Facet): instead of a getParent(ordinal) method, consider having a
-        /// <P>
-        /// getCategory(categorypath, prefixlen) which is similar to addCategory
+        /// </para>
+        /// <para>
+        /// TODO (Facet): instead of a <see cref="GetParent(int)">GetParent(ordinal)</see>
method, consider having a
+        /// GetCategory(categorypath, prefixlen) which is similar to <see cref="AddCategory"/>
         /// except it doesn't add new categories; This method can be used to get
         /// the ordinals of all prefixes of the given category, and it can use
-        /// exactly the same code and cache used by addCategory() so it means less code.
+        /// exactly the same code and cache used by <see cref="AddCategory"/> so it
means less code.
+        /// </para>
         /// </summary>
         int GetParent(int ordinal);
 
         /// <summary>
-        /// getSize() returns the number of categories in the taxonomy.
+        /// <see cref="Count"/> returns the number of categories in the taxonomy.
         /// <P>
         /// Because categories are numbered consecutively starting with 0, it
-        /// means the taxonomy contains ordinals 0 through getSize()-1.
+        /// means the taxonomy contains ordinals 0 through <see cref="Count"/>-1.
         /// <P>
-        /// Note that the number returned by getSize() is often slightly higher
+        /// Note that the number returned by <see cref="Count"/> is often slightly
higher
         /// than the number of categories inserted into the taxonomy; This is
         /// because when a category is added to the taxonomy, its ancestors
         /// are also added automatically (including the root, which always get
@@ -106,7 +114,7 @@ namespace Lucene.Net.Facet.Taxonomy
 
         /// <summary>
         /// Sets the commit user data map. That method is considered a transaction and
-        /// will be <seealso cref="#commit() committed"/> even if no other changes
were made to
+        /// will be <see cref="Index.IndexWriter.Commit">committed</see> even
if no other changes were made to
         /// the writer instance.
         /// <para>
         /// <b>NOTE:</b> the map is cloned internally, therefore altering the
map's

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/44958102/src/Lucene.Net.Facet/Taxonomy/WriterCache/CategoryPathUtils.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/WriterCache/CategoryPathUtils.cs b/src/Lucene.Net.Facet/Taxonomy/WriterCache/CategoryPathUtils.cs
index 800fda0..c2714c6 100644
--- a/src/Lucene.Net.Facet/Taxonomy/WriterCache/CategoryPathUtils.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/WriterCache/CategoryPathUtils.cs
@@ -20,11 +20,13 @@ namespace Lucene.Net.Facet.Taxonomy.WriterCache
      */
 
     /// <summary>
-    /// Utilities for use of <seealso cref="FacetLabel"/> by <seealso cref="CompactLabelToOrdinal"/>.
</summary>
+    /// Utilities for use of <see cref="FacetLabel"/> by <see cref="CompactLabelToOrdinal"/>.
+    /// </summary>
     internal class CategoryPathUtils
     {
         /// <summary>
-        /// Serializes the given <seealso cref="FacetLabel"/> to the <seealso cref="CharBlockArray"/>.
</summary>
+        /// Serializes the given <see cref="FacetLabel"/> to the <see cref="CharBlockArray"/>.
+        /// </summary>
         public static void Serialize(FacetLabel cp, CharBlockArray charBlockArray)
         {
             charBlockArray.Append((char)cp.Length);
@@ -41,7 +43,7 @@ namespace Lucene.Net.Facet.Taxonomy.WriterCache
 
         /// <summary>
         /// Calculates a hash function of a path that was serialized with
-        /// <seealso cref="#serialize(FacetLabel, CharBlockArray)"/>.
+        /// <see cref="Serialize(FacetLabel, CharBlockArray)"/>.
         /// </summary>
         public static int HashCodeOfSerialized(CharBlockArray charBlockArray, int offset)
         {
@@ -62,8 +64,8 @@ namespace Lucene.Net.Facet.Taxonomy.WriterCache
         }
 
         /// <summary>
-        /// Check whether the <seealso cref="FacetLabel"/> is equal to the one serialized
in
-        /// <seealso cref="CharBlockArray"/>.
+        /// Check whether the <see cref="FacetLabel"/> is equal to the one serialized
in
+        /// <see cref="CharBlockArray"/>.
         /// </summary>
         public static bool EqualsToSerialized(FacetLabel cp, CharBlockArray charBlockArray,
int offset)
         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/44958102/src/Lucene.Net.Facet/Taxonomy/WriterCache/CharBlockArray.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/WriterCache/CharBlockArray.cs b/src/Lucene.Net.Facet/Taxonomy/WriterCache/CharBlockArray.cs
index 60a0726..a461da2 100644
--- a/src/Lucene.Net.Facet/Taxonomy/WriterCache/CharBlockArray.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/WriterCache/CharBlockArray.cs
@@ -24,7 +24,7 @@ namespace Lucene.Net.Facet.Taxonomy.WriterCache
      */
 
     /// <summary>
-    /// Similar to <seealso cref="StringBuilder"/>, but with a more efficient growing
strategy.
+    /// Similar to <see cref="StringBuilder"/>, but with a more efficient growing strategy.
     /// This class uses char array blocks to grow.
     /// 
     /// @lucene.experimental

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/44958102/src/Lucene.Net.Facet/Taxonomy/WriterCache/Cl2oTaxonomyWriterCache.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/WriterCache/Cl2oTaxonomyWriterCache.cs b/src/Lucene.Net.Facet/Taxonomy/WriterCache/Cl2oTaxonomyWriterCache.cs
index 6cbff1f..a6f6ff8 100644
--- a/src/Lucene.Net.Facet/Taxonomy/WriterCache/Cl2oTaxonomyWriterCache.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/WriterCache/Cl2oTaxonomyWriterCache.cs
@@ -20,9 +20,9 @@ namespace Lucene.Net.Facet.Taxonomy.WriterCache
      */
 
     /// <summary>
-    /// <seealso cref="TaxonomyWriterCache"/> using <seealso cref="CompactLabelToOrdinal"/>.
Although
+    /// <see cref="ITaxonomyWriterCache"/> using <see cref="CompactLabelToOrdinal"/>.
Although
     /// called cache, it maintains in memory all the mappings from category to
-    /// ordinal, relying on that <seealso cref="CompactLabelToOrdinal"/> is an efficient
+    /// ordinal, relying on that <see cref="CompactLabelToOrdinal"/> is an efficient
     /// mapping for this purpose.
     /// 
     /// @lucene.experimental
@@ -37,7 +37,8 @@ namespace Lucene.Net.Facet.Taxonomy.WriterCache
         private volatile CompactLabelToOrdinal cache;
 
         /// <summary>
-        /// Sole constructor. </summary>
+        /// Sole constructor.
+        /// </summary>
         public Cl2oTaxonomyWriterCache(int initialCapcity, float loadFactor, int numHashArrays)
         {
             this.cache = new CompactLabelToOrdinal(initialCapcity, loadFactor, numHashArrays);
@@ -106,7 +107,8 @@ namespace Lucene.Net.Facet.Taxonomy.WriterCache
         }
 
         /// <summary>
-        /// Returns the number of bytes in memory used by this object. </summary>
+        /// Returns the number of bytes in memory used by this object.
+        /// </summary>
         public virtual int GetMemoryUsage()
         {
             return cache == null ? 0 : cache.GetMemoryUsage();

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/44958102/src/Lucene.Net.Facet/Taxonomy/WriterCache/CollisionMap.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/WriterCache/CollisionMap.cs b/src/Lucene.Net.Facet/Taxonomy/WriterCache/CollisionMap.cs
index b199513..a03f1bb 100644
--- a/src/Lucene.Net.Facet/Taxonomy/WriterCache/CollisionMap.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/WriterCache/CollisionMap.cs
@@ -22,7 +22,7 @@ namespace Lucene.Net.Facet.Taxonomy.WriterCache
      */
 
     /// <summary>
-    /// HashMap to store colliding labels. See <seealso cref="CompactLabelToOrdinal"/>
for
+    /// HashMap to store colliding labels. See <see cref="CompactLabelToOrdinal"/>
for
     /// details.
     /// 
     /// @lucene.experimental
@@ -75,7 +75,8 @@ namespace Lucene.Net.Facet.Taxonomy.WriterCache
         }
 
         /// <summary>
-        /// How many mappings. </summary>
+        /// How many mappings.
+        /// </summary>
         public virtual int Count
         {
             get
@@ -125,9 +126,8 @@ namespace Lucene.Net.Facet.Taxonomy.WriterCache
         }
 
         /// <summary>
-        /// Return the mapping, or {@link
-        ///  LabelToOrdinal#INVALID_ORDINAL} if the label isn't
-        ///  recognized. 
+        /// Return the mapping, or <see cref="LabelToOrdinal.INVALID_ORDINAL"/> 
+        /// if the label isn't recognized. 
         /// </summary>
         public virtual int Get(FacetLabel label, int hash)
         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/44958102/src/Lucene.Net.Facet/Taxonomy/WriterCache/CompactLabelToOrdinal.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/WriterCache/CompactLabelToOrdinal.cs b/src/Lucene.Net.Facet/Taxonomy/WriterCache/CompactLabelToOrdinal.cs
index 35d3ee5..da3a8fc 100644
--- a/src/Lucene.Net.Facet/Taxonomy/WriterCache/CompactLabelToOrdinal.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/WriterCache/CompactLabelToOrdinal.cs
@@ -22,21 +22,21 @@ namespace Lucene.Net.Facet.Taxonomy.WriterCache
      */
 
     /// <summary>
-    /// This is a very efficient LabelToOrdinal implementation that uses a
-    /// CharBlockArray to store all labels and a configurable number of HashArrays to
+    /// This is a very efficient <see cref="LabelToOrdinal"/> implementation that uses
a
+    /// <see cref="CharBlockArray"/> to store all labels and a configurable number
of <see cref="HashArray"/>s to
     /// reference the labels.
     /// <para>
-    /// Since the HashArrays don't handle collisions, a <seealso cref="CollisionMap"/>
is used
+    /// Since the <see cref="HashArray"/>s don't handle collisions, a <see cref="CollisionMap"/>
is used
     /// to store the colliding labels.
     /// </para>
     /// <para>
     /// This data structure grows by adding a new HashArray whenever the number of
-    /// collisions in the <seealso cref="CollisionMap"/> exceeds {@code loadFactor}
* 
-    /// <seealso cref="#getMaxOrdinal()"/>. Growing also includes reinserting all colliding
-    /// labels into the HashArrays to possibly reduce the number of collisions.
+    /// collisions in the <see cref="CollisionMap"/> exceeds <see cref="loadFactor"/>
* 
+    /// <see cref="GetMaxOrdinal()"/>. Growing also includes reinserting all colliding
+    /// labels into the <see cref="HashArray"/>s to possibly reduce the number of collisions.
     /// 
-    /// For setting the {@code loadFactor} see 
-    /// <seealso cref="#CompactLabelToOrdinal(int, float, int)"/>. 
+    /// For setting the <see cref="loadFactor"/> see 
+    /// <see cref="CompactLabelToOrdinal(int, float, int)"/>. 
     /// 
     /// </para>
     /// <para>
@@ -66,7 +66,8 @@ namespace Lucene.Net.Facet.Taxonomy.WriterCache
         private float loadFactor;
 
         /// <summary>
-        /// How many labels. </summary>
+        /// How many labels. 
+        /// </summary>
         public virtual int SizeOfMap
         {
             get
@@ -80,7 +81,8 @@ namespace Lucene.Net.Facet.Taxonomy.WriterCache
         }
 
         /// <summary>
-        /// Sole constructor. </summary>
+        /// Sole constructor.
+        /// </summary>
         public CompactLabelToOrdinal(int initialCapacity, float loadFactor, int numHashArrays)
         {
             this.hashArrays = new HashArray[numHashArrays];
@@ -293,7 +295,8 @@ namespace Lucene.Net.Facet.Taxonomy.WriterCache
         }
 
         /// <summary>
-        /// Returns index for hash code h. </summary>
+        /// Returns index for hash code h.
+        /// </summary>
         internal static int IndexFor(int h, int length)
         {
             return h & (length - 1);
@@ -389,7 +392,7 @@ namespace Lucene.Net.Facet.Taxonomy.WriterCache
 
         /// <summary>
         /// Opens the file and reloads the CompactLabelToOrdinal. The file it expects
-        /// is generated from the <seealso cref="#flush(File)"/> command.
+        /// is generated from the <see cref="Flush(Stream)"/> command.
         /// </summary>
         internal static CompactLabelToOrdinal Open(FileInfo file, float loadFactor, int numHashArrays)
         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/44958102/src/Lucene.Net.Facet/Taxonomy/WriterCache/LabelToOrdinal.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/WriterCache/LabelToOrdinal.cs b/src/Lucene.Net.Facet/Taxonomy/WriterCache/LabelToOrdinal.cs
index c9b36d6..bcb53ad 100644
--- a/src/Lucene.Net.Facet/Taxonomy/WriterCache/LabelToOrdinal.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/WriterCache/LabelToOrdinal.cs
@@ -29,13 +29,14 @@
         protected internal int counter;
 
         /// <summary>
-        /// Returned by <seealso cref="#getOrdinal"/> when the label isn't
-        ///  recognized. 
+        /// Returned by <see cref="GetOrdinal"/> when the label isn't
+        /// recognized. 
         /// </summary>
         public const int INVALID_ORDINAL = -2;
 
         /// <summary>
-        /// Default constructor. </summary>
+        /// Default constructor.
+        /// </summary>
         public LabelToOrdinal()
         {
         }
@@ -62,14 +63,14 @@
 
         /// <summary>
         /// Adds a new label if its not yet in the table.
-        /// Throws an <seealso cref="IllegalArgumentException"/> if the same label
with
+        /// Throws an <see cref="System.ArgumentException"/> if the same label with
         /// a different ordinal was previoulsy added to this table.
         /// </summary>
         public abstract void AddLabel(FacetLabel label, int ordinal);
 
         /// <summary>
         /// Returns the ordinal assigned to the given label, 
-        /// or <seealso cref="#INVALID_ORDINAL"/> if the label cannot be found in this
table.
+        /// or <see cref="INVALID_ORDINAL"/> if the label cannot be found in this table.
         /// </summary>
         public abstract int GetOrdinal(FacetLabel label);
     }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/44958102/src/Lucene.Net.Facet/Taxonomy/WriterCache/LruTaxonomyWriterCache.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/WriterCache/LruTaxonomyWriterCache.cs b/src/Lucene.Net.Facet/Taxonomy/WriterCache/LruTaxonomyWriterCache.cs
index 7152094..3f6c4dc 100644
--- a/src/Lucene.Net.Facet/Taxonomy/WriterCache/LruTaxonomyWriterCache.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/WriterCache/LruTaxonomyWriterCache.cs
@@ -18,7 +18,7 @@
      */
 
     /// <summary>
-    /// LRU <seealso cref="TaxonomyWriterCache"/> - good choice for huge taxonomies.
+    /// LRU <see cref="ITaxonomyWriterCache"/> - good choice for huge taxonomies.
     /// 
     /// @lucene.experimental
     /// </summary>
@@ -47,7 +47,8 @@
         private NameIntCacheLRU cache;
 
         /// <summary>
-        /// Creates this with <seealso cref="LRUType#LRU_HASHED"/> method. </summary>
+        /// Creates this with <see cref="LRUType.LRU_HASHED"/> method.
+        /// </summary>
         public LruTaxonomyWriterCache(int cacheSize)
             : this(cacheSize, LRUType.LRU_HASHED)
         {
@@ -60,7 +61,8 @@
         }
 
         /// <summary>
-        /// Creates this with the specified method. </summary>
+        /// Creates this with the specified method.
+        /// </summary>
         public LruTaxonomyWriterCache(int cacheSize, LRUType lruType)
         {
             // TODO (Facet): choose between NameHashIntCacheLRU and NameIntCacheLRU.

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/44958102/src/Lucene.Net.Facet/Taxonomy/WriterCache/NameIntCacheLRU.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/WriterCache/NameIntCacheLRU.cs b/src/Lucene.Net.Facet/Taxonomy/WriterCache/NameIntCacheLRU.cs
index ca0011a..b7264a0 100644
--- a/src/Lucene.Net.Facet/Taxonomy/WriterCache/NameIntCacheLRU.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/WriterCache/NameIntCacheLRU.cs
@@ -26,8 +26,10 @@ namespace Lucene.Net.Facet.Taxonomy.WriterCache
     /// 
     /// @lucene.experimental
     /// </summary>
-    // Note: Nothing in this class is synchronized. The caller is assumed to be
-    // synchronized so that no two methods of this class are called concurrently.
+    /// <remarks>
+    /// Note: Nothing in this class is synchronized. The caller is assumed to be
+    /// synchronized so that no two methods of this class are called concurrently.
+    /// </remarks>
     public class NameIntCacheLRU
     {
         private Dictionary<object, int?> cache;
@@ -42,7 +44,8 @@ namespace Lucene.Net.Facet.Taxonomy.WriterCache
         }
 
         /// <summary>
-        /// Maximum number of cache entries before eviction. </summary>
+        /// Maximum number of cache entries before eviction.
+        /// </summary>
         public virtual int Capacity
         {
             get
@@ -52,7 +55,8 @@ namespace Lucene.Net.Facet.Taxonomy.WriterCache
         }
 
         /// <summary>
-        /// Number of entries currently in the cache. </summary>
+        /// Number of entries currently in the cache.
+        /// </summary>
         public virtual int Count
         {
             get
@@ -91,7 +95,8 @@ namespace Lucene.Net.Facet.Taxonomy.WriterCache
         }
 
         /// <summary>
-        /// Subclasses can override this to provide caching by e.g. hash of the string. </summary>
+        /// Subclasses can override this to provide caching by e.g. hash of the string.
+        /// </summary>
         internal virtual object Key(FacetLabel name)
         {
             return name;
@@ -140,7 +145,7 @@ namespace Lucene.Net.Facet.Taxonomy.WriterCache
         /// If cache is full remove least recently used entries from cache. Return true
         /// if anything was removed, false otherwise.
         /// 
-        /// See comment in DirectoryTaxonomyWriter.addToCache(CategoryPath, int) for an
+        /// See comment in <see cref="Directory.DirectoryTaxonomyWriter.AddToCache(FacetLabel,
int)"/> for an
         /// explanation why we clean 2/3rds of the cache, and not just one entry.
         /// </summary>
         internal virtual bool MakeRoomLRU()

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/44958102/src/Lucene.Net.Facet/Taxonomy/WriterCache/TaxonomyWriterCache.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/WriterCache/TaxonomyWriterCache.cs b/src/Lucene.Net.Facet/Taxonomy/WriterCache/TaxonomyWriterCache.cs
index 1dc4d64..bb2eec8 100644
--- a/src/Lucene.Net.Facet/Taxonomy/WriterCache/TaxonomyWriterCache.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/WriterCache/TaxonomyWriterCache.cs
@@ -22,22 +22,22 @@
     /// <summary>
     /// ITaxonomyWriterCache is a relatively simple interface for a cache of
     /// category->ordinal mappings, used in ITaxonomyWriter implementations (such as
-    /// <seealso cref="DirectoryTaxonomyWriter"/>).
+    /// <see cref="DirectoryTaxonomyWriter"/>).
     /// <para>
-    /// It basically has put() methods for adding a mapping, and get() for looking a
-    /// mapping up the cache. The cache does <B>not</B> guarantee to hold everything
+    /// It basically has <see cref="Put"/> methods for adding a mapping, and <see
cref="Get"/> for looking a
+    /// mapping up the cache. The cache does <b>not</b> guarantee to hold everything
     /// that has been put into it, and might in fact selectively delete some of the
-    /// mappings (e.g., the ones least recently used). This means that if get()
+    /// mappings (e.g., the ones least recently used). This means that if <see cref="Get"/>
     /// returns a negative response, it does not necessarily mean that the category
     /// doesn't exist - just that it is not in the cache. The caller can only infer
     /// that the category doesn't exist if it knows the cache to be complete (because
-    /// all the categories were loaded into the cache, and since then no put()
+    /// all the categories were loaded into the cache, and since then no <see cref="Put"/>
     /// returned true).
     /// </para>
     /// <para>
     /// However, if it does so, it should clear out large parts of the cache at once,
     /// because the user will typically need to work hard to recover from every cache
-    /// cleanup (see <seealso cref="#put(FacetLabel, int)"/>'s return value).
+    /// cleanup (see <see cref="Put(FacetLabel, int)"/>'s return value).
     /// </para>
     /// <para>
     /// <b>NOTE:</b> the cache may be accessed concurrently by multiple threads,
@@ -49,7 +49,7 @@
     public interface ITaxonomyWriterCache
     {
         /// <summary>
-        /// Let go of whatever resources the cache is holding. After a close(),
+        /// Let go of whatever resources the cache is holding. After a <see cref="Close()"/>,
         /// this object can no longer be used.
         /// </summary>
         void Close();
@@ -57,43 +57,47 @@
         /// <summary>
         /// Lookup a category in the cache, returning its ordinal, or a negative
         /// number if the category is not in the cache.
-        /// <P>
+        /// <para>
         /// It is up to the caller to remember what a negative response means:
-        /// If the caller knows the cache is <I>complete</I> (it was initially
-        /// fed with all the categories, and since then put() never returned true)
+        /// If the caller knows the cache is <i>complete</i> (it was initially
+        /// fed with all the categories, and since then <see cref="Put"/> never returned
true)
         /// it means the category does not exist. Otherwise, the category might
         /// still exist, but just be missing from the cache.
+        /// </para>
         /// </summary>
         int Get(FacetLabel categoryPath);
 
         /// <summary>
         /// Add a category to the cache, with the given ordinal as the value.
-        /// <P>
+        /// <para>
         /// If the implementation keeps only a partial cache (e.g., an LRU cache)
         /// and finds that its cache is full, it should clear up part of the cache
-        /// and return <code>true</code>. Otherwise, it should return
-        /// <code>false</code>.
-        /// <P>
+        /// and return <c>true</c>. Otherwise, it should return
+        /// <c>false</c>.
+        /// </para>
+        /// <para>
         /// The reason why the caller needs to know if part of the cache was
         /// cleared is that in that case it will have to commit its on-disk index
         /// (so that all the latest category additions can be searched on disk, if
         /// we can't rely on the cache to contain them).
-        /// <P>
+        /// </para>
+        /// <para>
         /// Ordinals should be non-negative. Currently there is no defined way to
         /// specify that a cache should remember a category does NOT exist.
         /// It doesn't really matter, because normally the next thing we do after
         /// finding that a category does not exist is to add it.
+        /// </para>
         /// </summary>
         bool Put(FacetLabel categoryPath, int ordinal);
 
         /// <summary>
-        /// Returns true if the cache is full, such that the next <seealso cref="#put"/>
will
+        /// Returns true if the cache is full, such that the next <see cref="Put"/>
will
         /// evict entries from it, false otherwise.
         /// </summary>
         bool IsFull { get; }
 
         /// <summary>
-        /// Clears the content of the cache. Unlike <seealso cref="#close()"/>, the
caller can
+        /// Clears the content of the cache. Unlike <see cref="Close()"/>, the caller
can
         /// assume that the cache is still operable after this method returns.
         /// </summary>
         void Clear();

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/44958102/src/Lucene.Net.Facet/TopOrdAndFloatQueue.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/TopOrdAndFloatQueue.cs b/src/Lucene.Net.Facet/TopOrdAndFloatQueue.cs
index 9c81f31..756bd94 100644
--- a/src/Lucene.Net.Facet/TopOrdAndFloatQueue.cs
+++ b/src/Lucene.Net.Facet/TopOrdAndFloatQueue.cs
@@ -21,12 +21,13 @@ namespace Lucene.Net.Facet
 
     /// <summary>
     /// Keeps highest results, first by largest float value,
-    ///  then tie break by smallest ord. 
+    /// then tie break by smallest ord. 
     /// </summary>
     public class TopOrdAndFloatQueue : PriorityQueue<TopOrdAndFloatQueue.OrdAndValue>
     {
         /// <summary>
-        /// Holds a single entry. </summary>
+        /// Holds a single entry.
+        /// </summary>
         public sealed class OrdAndValue
         {
             /// <summary>
@@ -38,14 +39,16 @@ namespace Lucene.Net.Facet
             public float Value { get; set; }
 
             /// <summary>
-            /// Default constructor. </summary>
+            /// Default constructor.
+            /// </summary>
             public OrdAndValue()
             {
             }
         }
 
         /// <summary>
-        /// Sole constructor. </summary>
+        /// Sole constructor.
+        /// </summary>
         public TopOrdAndFloatQueue(int topN) : base(topN, false)
         {
         }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/44958102/src/Lucene.Net.Facet/TopOrdAndIntQueue.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/TopOrdAndIntQueue.cs b/src/Lucene.Net.Facet/TopOrdAndIntQueue.cs
index 7016e80..d9fbbfe 100644
--- a/src/Lucene.Net.Facet/TopOrdAndIntQueue.cs
+++ b/src/Lucene.Net.Facet/TopOrdAndIntQueue.cs
@@ -21,12 +21,13 @@ namespace Lucene.Net.Facet
 
     /// <summary>
     /// Keeps highest results, first by largest int value,
-    ///  then tie break by smallest ord. 
+    /// then tie break by smallest ord. 
     /// </summary>
     public class TopOrdAndIntQueue : PriorityQueue<TopOrdAndIntQueue.OrdAndValue>
     {
         /// <summary>
-        /// Holds a single entry. </summary>
+        /// Holds a single entry.
+        /// </summary>
         public sealed class OrdAndValue
         {
             /// <summary>
@@ -38,14 +39,16 @@ namespace Lucene.Net.Facet
             public int Value { get; set; }
 
             /// <summary>
-            /// Default constructor. </summary>
+            /// Default constructor.
+            /// </summary>
             public OrdAndValue()
             {
             }
         }
 
         /// <summary>
-        /// Sole constructor. </summary>
+        /// Sole constructor.
+        /// </summary>
         public TopOrdAndIntQueue(int topN)
             : base(topN, false)
         {


Mime
View raw message