You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucenenet.apache.org by ni...@apache.org on 2017/06/06 00:12:04 UTC
[31/48] lucenenet git commit: Lucene.Net.Util.Automaton: Fixed XML
documentation comments
Lucene.Net.Util.Automaton: Fixed XML documentation comments
Project: http://git-wip-us.apache.org/repos/asf/lucenenet/repo
Commit: http://git-wip-us.apache.org/repos/asf/lucenenet/commit/9bd4dc81
Tree: http://git-wip-us.apache.org/repos/asf/lucenenet/tree/9bd4dc81
Diff: http://git-wip-us.apache.org/repos/asf/lucenenet/diff/9bd4dc81
Branch: refs/heads/master
Commit: 9bd4dc81e541e325d17e742090b97a5e85693690
Parents: 7303348
Author: Shad Storhaug <sh...@shadstorhaug.com>
Authored: Mon Jun 5 02:26:30 2017 +0700
Committer: Shad Storhaug <sh...@shadstorhaug.com>
Committed: Mon Jun 5 06:16:27 2017 +0700
----------------------------------------------------------------------
CONTRIBUTING.md | 5 +-
src/Lucene.Net/Util/Automaton/Automaton.cs | 137 +++--
.../Util/Automaton/AutomatonProvider.cs | 12 +-
src/Lucene.Net/Util/Automaton/BasicAutomata.cs | 30 +-
.../Util/Automaton/BasicOperations.cs | 77 +--
.../Util/Automaton/ByteRunAutomaton.cs | 6 +-
.../Util/Automaton/CharacterRunAutomaton.cs | 6 +-
.../Util/Automaton/CompiledAutomaton.cs | 35 +-
.../Automaton/DaciukMihovAutomatonBuilder.cs | 50 +-
.../Util/Automaton/LevenshteinAutomata.cs | 55 +-
.../Util/Automaton/MinimizationOperations.cs | 4 +-
src/Lucene.Net/Util/Automaton/RegExp.cs | 576 ++++++++++---------
src/Lucene.Net/Util/Automaton/RunAutomaton.cs | 13 +-
src/Lucene.Net/Util/Automaton/SortedIntSet.cs | 6 +-
.../Util/Automaton/SpecialOperations.cs | 20 +-
src/Lucene.Net/Util/Automaton/State.cs | 44 +-
src/Lucene.Net/Util/Automaton/StatePair.cs | 18 +-
src/Lucene.Net/Util/Automaton/Transition.cs | 26 +-
src/Lucene.Net/Util/Automaton/UTF32ToUTF8.cs | 11 +-
19 files changed, 567 insertions(+), 564 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9bd4dc81/CONTRIBUTING.md
----------------------------------------------------------------------
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 0f04d03..d387b33 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -52,9 +52,8 @@ helpers to help with that, see for examples see our [Java style methods to avoid
1. Lucene.Net.Core (project)
1. Codecs (namespace)
- 2. Util.Automaton (namespace)
- 3. Util.Mutable (namespace)
- 4. Util.Packed (namespace)
+ 2. Util.Mutable (namespace)
+ 3. Util.Packed (namespace)
2. Lucene.Net.Codecs (project)
See [Documenting Lucene.Net](https://cwiki.apache.org/confluence/display/LUCENENET/Documenting+Lucene.Net) for instructions.
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9bd4dc81/src/Lucene.Net/Util/Automaton/Automaton.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Util/Automaton/Automaton.cs b/src/Lucene.Net/Util/Automaton/Automaton.cs
index 5741337..497fd97 100644
--- a/src/Lucene.Net/Util/Automaton/Automaton.cs
+++ b/src/Lucene.Net/Util/Automaton/Automaton.cs
@@ -39,35 +39,35 @@ namespace Lucene.Net.Util.Automaton
{
/// <summary>
/// Finite-state automaton with regular expression operations.
- /// <p>
+ /// <para/>
/// Class invariants:
- /// <ul>
- /// <li>An automaton is either represented explicitly (with <seealso cref="State"/> and
- /// <seealso cref="Transition"/> objects) or with a singleton string (see
- /// <seealso cref="Singleton"/> and <seealso cref="ExpandSingleton()"/>) in case the automaton
- /// is known to accept exactly one string. (Implicitly, all states and
- /// transitions of an automaton are reachable from its initial state.)
- /// <li>Automata are always reduced (see <seealso cref="#reduce()"/>) and have no
- /// transitions to dead states (see <seealso cref="#removeDeadTransitions()"/>).
- /// <li>If an automaton is nondeterministic, then <seealso cref="#isDeterministic()"/>
- /// returns false (but the converse is not required).
- /// <li>Automata provided as input to operations are generally assumed to be
- /// disjoint.
- /// </ul>
- /// <p>
+ /// <list type="bullet">
+ /// <item><description>An automaton is either represented explicitly (with <see cref="State"/> and
+ /// <see cref="Transition"/> objects) or with a singleton string (see
+ /// <see cref="Singleton"/> and <see cref="ExpandSingleton()"/>) in case the automaton
+ /// is known to accept exactly one string. (Implicitly, all states and
+ /// transitions of an automaton are reachable from its initial state.)</description></item>
+ /// <item><description>Automata are always reduced (see <see cref="Reduce()"/>) and have no
+ /// transitions to dead states (see <see cref="RemoveDeadTransitions()"/>).</description></item>
+ /// <item><description>If an automaton is nondeterministic, then <see cref="IsDeterministic"/>
+ /// returns <c>false</c> (but the converse is not required).</description></item>
+ /// <item><description>Automata provided as input to operations are generally assumed to be
+ /// disjoint.</description></item>
+ /// </list>
+ /// <para/>
/// If the states or transitions are manipulated manually, the
- /// <seealso cref="#restoreInvariant()"/> and <seealso cref="#setDeterministic(boolean)"/> methods
+ /// <see cref="RestoreInvariant()"/> method and <see cref="IsDeterministic"/> setter
/// should be used afterwards to restore representation invariants that are
/// assumed by the built-in automata operations.
///
- /// <p>
- /// <p>
+ /// <para/>
+ /// <para>
/// Note: this class has internal mutable state and is not thread safe. It is
/// the caller's responsibility to ensure any necessary synchronization if you
/// wish to use the same Automaton from multiple threads. In general it is instead
- /// recommended to use a <seealso cref="RunAutomaton"/> for multithreaded matching: it is immutable,
+ /// recommended to use a <see cref="RunAutomaton"/> for multithreaded matching: it is immutable,
/// thread safe, and much faster.
- /// </p>
+ /// </para>
/// @lucene.experimental
/// </summary>
public class Automaton
@@ -76,11 +76,11 @@ namespace Lucene.Net.Util.Automaton
/// Minimize using Hopcroft's O(n log n) algorithm. this is regarded as one of
/// the most generally efficient algorithms that exist.
/// </summary>
- /// <seealso cref= #setMinimization(int) </seealso>
+ /// <seealso cref="SetMinimization(int)"/>
public const int MINIMIZE_HOPCROFT = 2;
/// <summary>
- /// Selects minimization algorithm (default: <code>MINIMIZE_HOPCROFT</code>). </summary>
+ /// Selects minimization algorithm (default: <c>MINIMIZE_HOPCROFT</c>). </summary>
internal static int minimization = MINIMIZE_HOPCROFT;
/// <summary>
@@ -88,19 +88,18 @@ namespace Lucene.Net.Util.Automaton
internal State initial;
/// <summary>
- /// If true, then this automaton is definitely deterministic (i.e., there are
+ /// If <c>true</c>, then this automaton is definitely deterministic (i.e., there are
/// no choices for any run, but a run may crash).
/// </summary>
internal bool deterministic;
/// <summary>
/// Extra data associated with this automaton. </summary>
-
internal object info;
- /// <summary>
- /// Hash code. Recomputed by <seealso cref="MinimizationOperations#minimize(Automaton)"/>
- /// </summary>
+ ///// <summary>
+ ///// Hash code. Recomputed by <see cref="MinimizationOperations#minimize(Automaton)"/>
+ ///// </summary>
//int hash_code;
/// <summary>
@@ -113,17 +112,17 @@ namespace Lucene.Net.Util.Automaton
/// <summary>
/// Selects whether operations may modify the input automata (default:
- /// <code>false</code>).
+ /// <c>false</c>).
/// </summary>
internal static bool allow_mutation = false;
/// <summary>
/// Constructs a new automaton that accepts the empty language. Using this
- /// constructor, automata can be constructed manually from <seealso cref="State"/> and
- /// <seealso cref="Transition"/> objects.
+ /// constructor, automata can be constructed manually from <see cref="State"/> and
+ /// <see cref="Transition"/> objects.
/// </summary>
- /// <seealso cref= State </seealso>
- /// <seealso cref= Transition </seealso>
+ /// <seealso cref="State"/>
+ /// <seealso cref="Transition"/>
public Automaton(State initial)
{
this.initial = initial;
@@ -137,7 +136,7 @@ namespace Lucene.Net.Util.Automaton
}
/// <summary>
- /// Selects minimization algorithm (default: <code>MINIMIZE_HOPCROFT</code>).
+ /// Selects minimization algorithm (default: <c>MINIMIZE_HOPCROFT</c>).
/// </summary>
/// <param name="algorithm"> minimization algorithm </param>
public static void SetMinimization(int algorithm)
@@ -147,11 +146,11 @@ namespace Lucene.Net.Util.Automaton
/// <summary>
/// Sets or resets minimize always flag. If this flag is set, then
- /// <seealso cref="MinimizationOperations#minimize(Automaton)"/> will automatically be
+ /// <see cref="MinimizationOperations.Minimize(Automaton)"/> will automatically be
/// invoked after all operations that otherwise may produce non-minimal
/// automata. By default, the flag is not set.
/// </summary>
- /// <param name="flag"> if true, the flag is set </param>
+ /// <param name="flag"> if <c>true</c>, the flag is set </param>
public static void SetMinimizeAlways(bool flag)
{
minimize_always = flag;
@@ -163,7 +162,7 @@ namespace Lucene.Net.Util.Automaton
/// always leave input automata languages unmodified. By default, the flag is
/// not set.
/// </summary>
- /// <param name="flag"> if true, the flag is set </param>
+ /// <param name="flag"> if <c>true</c>, the flag is set </param>
/// <returns> previous value of the flag </returns>
public static bool SetAllowMutate(bool flag)
{
@@ -208,7 +207,7 @@ namespace Lucene.Net.Util.Automaton
/// exactly one string <i>may</i> be represented in singleton mode. In that
/// case, this method may be used to obtain the string.
/// </summary>
- /// <returns> string, null if this automaton is not in singleton mode. </returns>
+ /// <returns> String, <c>null</c> if this automaton is not in singleton mode. </returns>
public virtual string Singleton
{
get
@@ -217,10 +216,10 @@ namespace Lucene.Net.Util.Automaton
}
}
- /// <summary>
- /// Sets initial state.
- /// </summary>
- /// <param name="s"> state </param>
+ ///// <summary>
+ ///// Sets initial state.
+ ///// </summary>
+ ///// <param name="s"> state </param>
/*
public void setInitialState(State s) {
initial = s;
@@ -241,7 +240,7 @@ namespace Lucene.Net.Util.Automaton
/// <summary>
/// Returns deterministic flag for this automaton.
/// </summary>
- /// <returns> true if the automaton is definitely deterministic, false if the
+ /// <returns> <c>true</c> if the automaton is definitely deterministic, <c>false</c> if the
/// automaton may be nondeterministic </returns>
public virtual bool IsDeterministic
{
@@ -258,7 +257,7 @@ namespace Lucene.Net.Util.Automaton
/// <summary>
/// Associates extra information with this automaton.
/// </summary>
- /// <param name="info"> extra information </param>
+ /// <param name="value"> extra information </param>
public virtual object Info
{
set
@@ -352,7 +351,7 @@ namespace Lucene.Net.Util.Automaton
/// <summary>
/// Returns the set of reachable accept states.
/// </summary>
- /// <returns> set of <seealso cref="State"/> objects </returns>
+ /// <returns> Set of <see cref="State"/> objects. </returns>
public virtual ISet<State> GetAcceptStates()
{
ExpandSingleton();
@@ -413,11 +412,11 @@ namespace Lucene.Net.Util.Automaton
}
/// <summary>
- /// Restores representation invariant. this method must be invoked before any
+ /// Restores representation invariant. This method must be invoked before any
/// built-in automata operation is performed if automaton states or transitions
/// are manipulated manually.
/// </summary>
- /// <seealso cref= #setDeterministic(boolean) </seealso>
+ /// <seealso cref="IsDeterministic"/>
public virtual void RestoreInvariant()
{
RemoveDeadTransitions();
@@ -473,7 +472,7 @@ namespace Lucene.Net.Util.Automaton
/// Returns the set of live states. A state is "live" if an accept state is
/// reachable from it.
/// </summary>
- /// <returns> set of <seealso cref="State"/> objects </returns>
+ /// <returns> Set of <see cref="State"/> objects. </returns>
private State[] GetLiveStates()
{
State[] states = GetNumberedStates();
@@ -517,7 +516,7 @@ namespace Lucene.Net.Util.Automaton
}
/// <summary>
- /// Removes transitions to dead states and calls <seealso cref="#reduce()"/>.
+ /// Removes transitions to dead states and calls <see cref="Reduce()"/>.
/// (A state is "dead" if no accept state is
/// reachable from it.)
/// </summary>
@@ -620,7 +619,7 @@ namespace Lucene.Net.Util.Automaton
}
/// <summary>
- /// Returns the number of transitions in this automaton. this number is counted
+ /// Returns the number of transitions in this automaton. This number is counted
/// as the total number of edges, where one edge may be a character interval.
/// </summary>
public virtual int GetNumberOfTransitions()
@@ -693,9 +692,9 @@ namespace Lucene.Net.Util.Automaton
//throw new System.NotSupportedException();
}
- /// <summary>
- /// Must be invoked when the stored hash code may no longer be valid.
- /// </summary>
+ ///// <summary>
+ ///// Must be invoked when the stored hash code may no longer be valid.
+ ///// </summary>
/*
void clearHashCode() {
hash_code = 0;
@@ -780,7 +779,7 @@ namespace Lucene.Net.Util.Automaton
}
/// <summary>
- /// Returns a clone of this automaton unless <code>allow_mutation</code> is
+ /// Returns a clone of this automaton unless <see cref="allow_mutation"/> is
/// set, expands if singleton.
/// </summary>
internal virtual Automaton CloneExpandedIfRequired()
@@ -830,7 +829,7 @@ namespace Lucene.Net.Util.Automaton
/// <summary>
/// Returns a clone of this automaton, or this automaton itself if
- /// <code>allow_mutation</code> flag is set.
+ /// <see cref="allow_mutation"/> flag is set.
/// </summary>
internal virtual Automaton CloneIfRequired()
{
@@ -845,7 +844,7 @@ namespace Lucene.Net.Util.Automaton
}
/// <summary>
- /// See <seealso cref="BasicOperations#concatenate(Automaton, Automaton)"/>.
+ /// See <see cref="BasicOperations.Concatenate(Automaton, Automaton)"/>.
/// </summary>
public virtual Automaton Concatenate(Automaton a)
{
@@ -853,7 +852,7 @@ namespace Lucene.Net.Util.Automaton
}
/// <summary>
- /// See <seealso cref="BasicOperations#concatenate(List)"/>.
+ /// See <see cref="BasicOperations.Concatenate(IList{Automaton})"/>.
/// </summary>
public static Automaton Concatenate(IList<Automaton> l)
{
@@ -861,7 +860,7 @@ namespace Lucene.Net.Util.Automaton
}
/// <summary>
- /// See <seealso cref="BasicOperations#optional(Automaton)"/>.
+ /// See <see cref="BasicOperations.Optional(Automaton)"/>.
/// </summary>
public virtual Automaton Optional()
{
@@ -869,7 +868,7 @@ namespace Lucene.Net.Util.Automaton
}
/// <summary>
- /// See <seealso cref="BasicOperations#repeat(Automaton)"/>.
+ /// See <see cref="BasicOperations.Repeat(Automaton)"/>.
/// </summary>
public virtual Automaton Repeat()
{
@@ -877,7 +876,7 @@ namespace Lucene.Net.Util.Automaton
}
/// <summary>
- /// See <seealso cref="BasicOperations#repeat(Automaton, int)"/>.
+ /// See <see cref="BasicOperations.Repeat(Automaton, int)"/>.
/// </summary>
public virtual Automaton Repeat(int min)
{
@@ -885,7 +884,7 @@ namespace Lucene.Net.Util.Automaton
}
/// <summary>
- /// See <seealso cref="BasicOperations#repeat(Automaton, int, int)"/>.
+ /// See <see cref="BasicOperations.Repeat(Automaton, int, int)"/>.
/// </summary>
public virtual Automaton Repeat(int min, int max)
{
@@ -893,7 +892,7 @@ namespace Lucene.Net.Util.Automaton
}
/// <summary>
- /// See <seealso cref="BasicOperations#complement(Automaton)"/>.
+ /// See <see cref="BasicOperations.Complement(Automaton)"/>.
/// </summary>
public virtual Automaton Complement()
{
@@ -901,7 +900,7 @@ namespace Lucene.Net.Util.Automaton
}
/// <summary>
- /// See <seealso cref="BasicOperations#minus(Automaton, Automaton)"/>.
+ /// See <see cref="BasicOperations.Minus(Automaton, Automaton)"/>.
/// </summary>
public virtual Automaton Minus(Automaton a)
{
@@ -909,7 +908,7 @@ namespace Lucene.Net.Util.Automaton
}
/// <summary>
- /// See <seealso cref="BasicOperations#intersection(Automaton, Automaton)"/>.
+ /// See <see cref="BasicOperations.Intersection(Automaton, Automaton)"/>.
/// </summary>
public virtual Automaton Intersection(Automaton a)
{
@@ -917,7 +916,7 @@ namespace Lucene.Net.Util.Automaton
}
/// <summary>
- /// See <seealso cref="BasicOperations#subsetOf(Automaton, Automaton)"/>.
+ /// See <see cref="BasicOperations.SubsetOf(Automaton, Automaton)"/>.
/// </summary>
public virtual bool SubsetOf(Automaton a)
{
@@ -925,7 +924,7 @@ namespace Lucene.Net.Util.Automaton
}
/// <summary>
- /// See <seealso cref="BasicOperations#union(Automaton, Automaton)"/>.
+ /// See <see cref="BasicOperations.Union(Automaton, Automaton)"/>.
/// </summary>
public virtual Automaton Union(Automaton a)
{
@@ -933,7 +932,7 @@ namespace Lucene.Net.Util.Automaton
}
/// <summary>
- /// See <seealso cref="BasicOperations#union(Collection)"/>.
+ /// See <see cref="BasicOperations.Union(ICollection{Automaton})"/>.
/// </summary>
public static Automaton Union(ICollection<Automaton> l)
{
@@ -941,7 +940,7 @@ namespace Lucene.Net.Util.Automaton
}
/// <summary>
- /// See <seealso cref="BasicOperations#determinize(Automaton)"/>.
+ /// See <see cref="BasicOperations.Determinize(Automaton)"/>.
/// </summary>
public virtual void Determinize()
{
@@ -949,7 +948,7 @@ namespace Lucene.Net.Util.Automaton
}
/// <summary>
- /// See <seealso cref="BasicOperations#isEmptyString(Automaton)"/>.
+ /// See <see cref="BasicOperations.IsEmptyString(Automaton)"/>.
/// </summary>
public virtual bool IsEmptyString
{
@@ -960,7 +959,7 @@ namespace Lucene.Net.Util.Automaton
}
/// <summary>
- /// See <seealso cref="MinimizationOperations#minimize(Automaton)"/>. Returns the
+ /// See <see cref="MinimizationOperations.Minimize(Automaton)"/>. Returns the
/// automaton being given as argument.
/// </summary>
public static Automaton Minimize(Automaton a)
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9bd4dc81/src/Lucene.Net/Util/Automaton/AutomatonProvider.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Util/Automaton/AutomatonProvider.cs b/src/Lucene.Net/Util/Automaton/AutomatonProvider.cs
index bc0a1e5..1bb92ac 100644
--- a/src/Lucene.Net/Util/Automaton/AutomatonProvider.cs
+++ b/src/Lucene.Net/Util/Automaton/AutomatonProvider.cs
@@ -30,19 +30,19 @@
namespace Lucene.Net.Util.Automaton
{
/// <summary>
- /// Automaton provider for <code>RegExp.</code>
- /// <seealso cref="RegExp#toAutomaton(AutomatonProvider)"/>
- ///
+ /// Automaton provider for <see cref="RegExp"/>.
+ /// <para/>
/// @lucene.experimental
/// </summary>
+ /// <seealso cref="RegExp.ToAutomaton(IAutomatonProvider)"/>
public interface IAutomatonProvider
{
/// <summary>
/// Returns automaton of the given name.
/// </summary>
- /// <param name="name"> automaton name </param>
- /// <returns> automaton </returns>
- /// <exception cref="IOException"> if errors occur </exception>
+ /// <param name="name"> Automaton name. </param>
+ /// <returns> Automaton. </returns>
+ /// <exception cref="System.IO.IOException"> If errors occur. </exception>
Automaton GetAutomaton(string name);
}
}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9bd4dc81/src/Lucene.Net/Util/Automaton/BasicAutomata.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Util/Automaton/BasicAutomata.cs b/src/Lucene.Net/Util/Automaton/BasicAutomata.cs
index ff0f20f..d7b50e0 100644
--- a/src/Lucene.Net/Util/Automaton/BasicAutomata.cs
+++ b/src/Lucene.Net/Util/Automaton/BasicAutomata.cs
@@ -36,7 +36,7 @@ namespace Lucene.Net.Util.Automaton
{
/// <summary>
/// Construction of basic automata.
- ///
+ /// <para/>
/// @lucene.experimental
/// </summary>
internal sealed class BasicAutomata
@@ -127,7 +127,7 @@ namespace Lucene.Net.Util.Automaton
/// <summary>
/// Constructs sub-automaton corresponding to decimal numbers of length
- /// x.substring(n).length().
+ /// <c>x.Substring(n).Length</c>.
/// </summary>
private static State AnyOfRightLength(string x, int n)
{
@@ -145,7 +145,7 @@ namespace Lucene.Net.Util.Automaton
/// <summary>
/// Constructs sub-automaton corresponding to decimal numbers of value at least
- /// x.substring(n) and length x.substring(n).length().
+ /// <c>x.Substring(n)</c> and length <c>x.Substring(n).Length</c>.
/// </summary>
private static State AtLeast(string x, int n, ICollection<State> initials, bool zeros)
{
@@ -172,7 +172,7 @@ namespace Lucene.Net.Util.Automaton
/// <summary>
/// Constructs sub-automaton corresponding to decimal numbers of value at most
- /// x.substring(n) and length x.substring(n).length().
+ /// <c>x.Substring(n)</c> and length <c>x.Substring(n).Length</c>.
/// </summary>
private static State AtMost(string x, int n)
{
@@ -195,8 +195,8 @@ namespace Lucene.Net.Util.Automaton
/// <summary>
/// Constructs sub-automaton corresponding to decimal numbers of value between
- /// x.substring(n) and y.substring(n) and of length x.substring(n).length()
- /// (which must be equal to y.substring(n).length()).
+ /// <c>x.Substring(n)</c> and <c>y.Substring(n)</c> and of length <c>x.Substring(n).Length</c>
+ /// (which must be equal to <c>y.Substring(n).Length</c>).
/// </summary>
private static State Between(string x, string y, int n, ICollection<State> initials, bool zeros)
{
@@ -234,15 +234,15 @@ namespace Lucene.Net.Util.Automaton
/// Returns a new automaton that accepts strings representing decimal
/// non-negative integers in the given interval.
/// </summary>
- /// <param name="min"> minimal value of interval </param>
- /// <param name="max"> maximal value of interval (both end points are included in the
- /// interval) </param>
- /// <param name="digits"> if >0, use fixed number of digits (strings must be prefixed
+ /// <param name="min"> Minimal value of interval. </param>
+ /// <param name="max"> Maximal value of interval (both end points are included in the
+ /// interval). </param>
+ /// <param name="digits"> If > 0, use fixed number of digits (strings must be prefixed
/// by 0's to obtain the right length) - otherwise, the number of
- /// digits is not fixed </param>
- /// <exception cref="IllegalArgumentException"> if min>max or if numbers in the
+ /// digits is not fixed. </param>
+ /// <exception cref="ArgumentException"> If min > max or if numbers in the
/// interval cannot be expressed with the given fixed number of
- /// digits </exception>
+ /// digits. </exception>
public static Automaton MakeInterval(int min, int max, int digits)
{
Automaton a = new Automaton();
@@ -329,14 +329,14 @@ namespace Lucene.Net.Util.Automaton
/// <summary>
/// Returns a new (deterministic and minimal) automaton that accepts the union
- /// of the given collection of <seealso cref="BytesRef"/>s representing UTF-8 encoded
+ /// of the given collection of <see cref="BytesRef"/>s representing UTF-8 encoded
/// strings.
/// </summary>
/// <param name="utf8Strings">
/// The input strings, UTF-8 encoded. The collection must be in sorted
/// order.
/// </param>
- /// <returns> An <seealso cref="Automaton"/> accepting all input strings. The resulting
+ /// <returns> An <see cref="Automaton"/> accepting all input strings. The resulting
/// automaton is codepoint based (full unicode codepoints on
/// transitions). </returns>
public static Automaton MakeStringUnion(ICollection<BytesRef> utf8Strings)
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9bd4dc81/src/Lucene.Net/Util/Automaton/BasicOperations.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Util/Automaton/BasicOperations.cs b/src/Lucene.Net/Util/Automaton/BasicOperations.cs
index a5f53f7..62927dc 100644
--- a/src/Lucene.Net/Util/Automaton/BasicOperations.cs
+++ b/src/Lucene.Net/Util/Automaton/BasicOperations.cs
@@ -38,7 +38,7 @@ namespace Lucene.Net.Util.Automaton
{
/// <summary>
/// Basic automata operations.
- ///
+ /// <para/>
/// @lucene.experimental
/// </summary>
internal sealed class BasicOperations
@@ -50,7 +50,7 @@ namespace Lucene.Net.Util.Automaton
/// <summary>
/// Returns an automaton that accepts the concatenation of the languages of the
/// given automata.
- /// <p>
+ /// <para/>
/// Complexity: linear in number of states.
/// </summary>
public static Automaton Concatenate(Automaton a1, Automaton a2)
@@ -92,7 +92,7 @@ namespace Lucene.Net.Util.Automaton
/// <summary>
/// Returns an automaton that accepts the concatenation of the languages of the
/// given automata.
- /// <p>
+ /// <para/>
/// Complexity: linear in total number of states.
/// </summary>
public static Automaton Concatenate(IList<Automaton> l)
@@ -190,7 +190,7 @@ namespace Lucene.Net.Util.Automaton
/// <summary>
/// Returns an automaton that accepts the union of the empty string and the
/// language of the given automaton.
- /// <p>
+ /// <para/>
/// Complexity: linear in number of states.
/// </summary>
public static Automaton Optional(Automaton a)
@@ -211,7 +211,7 @@ namespace Lucene.Net.Util.Automaton
/// Returns an automaton that accepts the Kleene star (zero or more
/// concatenated repetitions) of the language of the given automaton. Never
/// modifies the input automaton language.
- /// <p>
+ /// <para/>
/// Complexity: linear in number of states.
/// </summary>
public static Automaton Repeat(Automaton a)
@@ -233,10 +233,10 @@ namespace Lucene.Net.Util.Automaton
}
/// <summary>
- /// Returns an automaton that accepts <code>min</code> or more concatenated
+ /// Returns an automaton that accepts <paramref name="min"/> or more concatenated
/// repetitions of the language of the given automaton.
- /// <p>
- /// Complexity: linear in number of states and in <code>min</code>.
+ /// <para/>
+ /// Complexity: linear in number of states and in <paramref name="min"/>.
/// </summary>
public static Automaton Repeat(Automaton a, int min)
{
@@ -254,12 +254,12 @@ namespace Lucene.Net.Util.Automaton
}
/// <summary>
- /// Returns an automaton that accepts between <code>min</code> and
- /// <code>max</code> (including both) concatenated repetitions of the language
+ /// Returns an automaton that accepts between <paramref name="min"/> and
+ /// <paramref name="max"/> (including both) concatenated repetitions of the language
/// of the given automaton.
- /// <p>
- /// Complexity: linear in number of states and in <code>min</code> and
- /// <code>max</code>.
+ /// <para/>
+ /// Complexity: linear in number of states and in <paramref name="min"/> and
+ /// <paramref name="max"/>.
/// </summary>
public static Automaton Repeat(Automaton a, int min, int max)
{
@@ -314,7 +314,7 @@ namespace Lucene.Net.Util.Automaton
/// <summary>
/// Returns a (deterministic) automaton that accepts the complement of the
/// language of the given automaton.
- /// <p>
+ /// <para/>
/// Complexity: linear in number of states (if already deterministic).
/// </summary>
public static Automaton Complement(Automaton a)
@@ -332,10 +332,10 @@ namespace Lucene.Net.Util.Automaton
/// <summary>
/// Returns a (deterministic) automaton that accepts the intersection of the
- /// language of <code>a1</code> and the complement of the language of
- /// <code>a2</code>. As a side-effect, the automata may be determinized, if not
+ /// language of <paramref name="a1"/> and the complement of the language of
+ /// <paramref name="a2"/>. As a side-effect, the automata may be determinized, if not
/// already deterministic.
- /// <p>
+ /// <para/>
/// Complexity: quadratic in number of states (if already deterministic).
/// </summary>
public static Automaton Minus(Automaton a1, Automaton a2)
@@ -365,7 +365,7 @@ namespace Lucene.Net.Util.Automaton
/// <summary>
/// Returns an automaton that accepts the intersection of the languages of the
/// given automata. Never modifies the input automata languages.
- /// <p>
+ /// <para/>
/// Complexity: quadratic in number of states.
/// </summary>
public static Automaton Intersection(Automaton a1, Automaton a2)
@@ -445,10 +445,10 @@ namespace Lucene.Net.Util.Automaton
}
/// <summary>
- /// Returns true if these two automata accept exactly the
- /// same language. this is a costly computation! Note
- /// also that a1 and a2 will be determinized as a side
- /// effect.
+ /// Returns <c>true</c> if these two automata accept exactly the
+ /// same language. This is a costly computation! Note
+ /// also that <paramref name="a1"/> and <paramref name="a2"/> will be determinized as a side
+ /// effect.
/// </summary>
public static bool SameLanguage(Automaton a1, Automaton a2)
{
@@ -472,10 +472,10 @@ namespace Lucene.Net.Util.Automaton
}
/// <summary>
- /// Returns true if the language of <code>a1</code> is a subset of the language
- /// of <code>a2</code>. As a side-effect, <code>a2</code> is determinized if
+ /// Returns true if the language of <paramref name="a1"/> is a subset of the language
+ /// of <paramref name="a2"/>. As a side-effect, <paramref name="a2"/> is determinized if
/// not already marked as deterministic.
- /// <p>
+ /// <para/>
/// Complexity: quadratic in number of states.
/// </summary>
public static bool SubsetOf(Automaton a1, Automaton a2)
@@ -552,7 +552,7 @@ namespace Lucene.Net.Util.Automaton
/// <summary>
/// Returns an automaton that accepts the union of the languages of the given
/// automata.
- /// <p>
+ /// <para/>
/// Complexity: linear in number of states.
/// </summary>
public static Automaton Union(Automaton a1, Automaton a2)
@@ -585,7 +585,7 @@ namespace Lucene.Net.Util.Automaton
/// <summary>
/// Returns an automaton that accepts the union of the languages of the given
/// automata.
- /// <p>
+ /// <para/>
/// Complexity: linear in number of states.
/// </summary>
public static Automaton Union(ICollection<Automaton> l)
@@ -780,7 +780,7 @@ namespace Lucene.Net.Util.Automaton
/// <summary>
/// Determinizes the given automaton.
- /// <p>
+ /// <para/>
/// Worst case complexity: exponential in number of states.
/// </summary>
public static void Determinize(Automaton a)
@@ -922,13 +922,14 @@ namespace Lucene.Net.Util.Automaton
}
/// <summary>
- /// Adds epsilon transitions to the given automaton. this method adds extra
+ /// Adds epsilon transitions to the given automaton. This method adds extra
/// character interval transitions that are equivalent to the given set of
/// epsilon transitions.
/// </summary>
- /// <param name="pairs"> collection of <seealso cref="StatePair"/> objects representing pairs of
+ /// <param name="a"> Automaton. </param>
+ /// <param name="pairs"> Collection of <see cref="StatePair"/> objects representing pairs of
/// source/destination states where epsilon transitions should be
- /// added </param>
+ /// added. </param>
public static void AddEpsilons(Automaton a, ICollection<StatePair> pairs)
{
a.ExpandSingleton();
@@ -1001,7 +1002,7 @@ namespace Lucene.Net.Util.Automaton
}
/// <summary>
- /// Returns true if the given automaton accepts the empty string and nothing
+ /// Returns <c>true</c> if the given automaton accepts the empty string and nothing
/// else.
/// </summary>
public static bool IsEmptyString(Automaton a)
@@ -1017,7 +1018,7 @@ namespace Lucene.Net.Util.Automaton
}
/// <summary>
- /// Returns true if the given automaton accepts no strings.
+ /// Returns <c>true</c> if the given automaton accepts no strings.
/// </summary>
public static bool IsEmpty(Automaton a)
{
@@ -1029,7 +1030,7 @@ namespace Lucene.Net.Util.Automaton
}
/// <summary>
- /// Returns true if the given automaton accepts all strings.
+ /// Returns <c>true</c> if the given automaton accepts all strings.
/// </summary>
public static bool IsTotal(Automaton a)
{
@@ -1048,11 +1049,11 @@ namespace Lucene.Net.Util.Automaton
}
/// <summary>
- /// Returns true if the given string is accepted by the automaton.
- /// <p>
+ /// Returns <c>true</c> if the given string is accepted by the automaton.
+ /// <para/>
/// Complexity: linear in the length of the string.
- /// <p>
- /// <b>Note:</b> for full performance, use the <seealso cref="RunAutomaton"/> class.
+ /// <para/>
+ /// <b>Note:</b> for full performance, use the <see cref="RunAutomaton"/> class.
/// </summary>
public static bool Run(Automaton a, string s)
{
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9bd4dc81/src/Lucene.Net/Util/Automaton/ByteRunAutomaton.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Util/Automaton/ByteRunAutomaton.cs b/src/Lucene.Net/Util/Automaton/ByteRunAutomaton.cs
index 096df3c..3a12c55 100644
--- a/src/Lucene.Net/Util/Automaton/ByteRunAutomaton.cs
+++ b/src/Lucene.Net/Util/Automaton/ByteRunAutomaton.cs
@@ -18,7 +18,7 @@ namespace Lucene.Net.Util.Automaton
*/
/// <summary>
- /// Automaton representation for matching UTF-8 byte[].
+ /// Automaton representation for matching UTF-8 <see cref="T:byte[]"/>.
/// </summary>
public class ByteRunAutomaton : RunAutomaton
{
@@ -28,14 +28,14 @@ namespace Lucene.Net.Util.Automaton
}
/// <summary>
- /// expert: if utf8 is true, the input is already byte-based </summary>
+ /// Expert: if utf8 is true, the input is already byte-based </summary>
public ByteRunAutomaton(Automaton a, bool utf8)
: base(utf8 ? a : (new UTF32ToUTF8()).Convert(a), 256, true)
{
}
/// <summary>
- /// Returns true if the given byte array is accepted by this automaton
+ /// Returns <c>true</c> if the given byte array is accepted by this automaton.
/// </summary>
public virtual bool Run(byte[] s, int offset, int length)
{
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9bd4dc81/src/Lucene.Net/Util/Automaton/CharacterRunAutomaton.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Util/Automaton/CharacterRunAutomaton.cs b/src/Lucene.Net/Util/Automaton/CharacterRunAutomaton.cs
index dc97e70..e9a31b5 100644
--- a/src/Lucene.Net/Util/Automaton/CharacterRunAutomaton.cs
+++ b/src/Lucene.Net/Util/Automaton/CharacterRunAutomaton.cs
@@ -20,7 +20,7 @@ namespace Lucene.Net.Util.Automaton
*/
/// <summary>
- /// Automaton representation for matching char[].
+ /// Automaton representation for matching <see cref="T:char[]"/>.
/// </summary>
public class CharacterRunAutomaton : RunAutomaton
{
@@ -30,7 +30,7 @@ namespace Lucene.Net.Util.Automaton
}
/// <summary>
- /// Returns true if the given string is accepted by this automaton.
+ /// Returns <c>true</c> if the given string is accepted by this automaton.
/// </summary>
public virtual bool Run(string s)
{
@@ -45,7 +45,7 @@ namespace Lucene.Net.Util.Automaton
}
/// <summary>
- /// Returns true if the given string is accepted by this automaton
+ /// Returns <c>true</c> if the given string is accepted by this automaton.
/// </summary>
public virtual bool Run(char[] s, int offset, int length)
{
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9bd4dc81/src/Lucene.Net/Util/Automaton/CompiledAutomaton.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Util/Automaton/CompiledAutomaton.cs b/src/Lucene.Net/Util/Automaton/CompiledAutomaton.cs
index bd60de4..9f1baa2 100644
--- a/src/Lucene.Net/Util/Automaton/CompiledAutomaton.cs
+++ b/src/Lucene.Net/Util/Automaton/CompiledAutomaton.cs
@@ -31,9 +31,9 @@ namespace Lucene.Net.Util.Automaton
/// <summary>
/// Immutable class holding compiled details for a given
- /// Automaton. The Automaton is deterministic, must not have
+ /// <see cref="Automaton"/>. The <see cref="Automaton"/> is deterministic, must not have
/// dead states but is not necessarily minimal.
- ///
+ /// <para/>
/// @lucene.experimental
/// </summary>
public class CompiledAutomaton
@@ -57,7 +57,7 @@ namespace Lucene.Net.Util.Automaton
SINGLE,
/// <summary>
- /// Automaton that matches all Strings with a constant prefix. </summary>
+ /// Automaton that matches all strings with a constant prefix. </summary>
PREFIX,
/// <summary>
@@ -68,14 +68,14 @@ namespace Lucene.Net.Util.Automaton
public AUTOMATON_TYPE Type { get; private set; }
/// <summary>
- /// For <seealso cref="AUTOMATON_TYPE#PREFIX"/>, this is the prefix term;
- /// for <seealso cref="AUTOMATON_TYPE#SINGLE"/> this is the singleton term.
+ /// For <see cref="AUTOMATON_TYPE.PREFIX"/>, this is the prefix term;
+ /// for <see cref="AUTOMATON_TYPE.SINGLE"/> this is the singleton term.
/// </summary>
public BytesRef Term { get; private set; }
/// <summary>
- /// Matcher for quickly determining if a byte[] is accepted.
- /// only valid for <seealso cref="AUTOMATON_TYPE#NORMAL"/>.
+ /// Matcher for quickly determining if a <see cref="T:byte[]"/> is accepted.
+ /// only valid for <see cref="AUTOMATON_TYPE.NORMAL"/>.
/// </summary>
public ByteRunAutomaton RunAutomaton { get; private set; }
@@ -84,8 +84,9 @@ namespace Lucene.Net.Util.Automaton
/// <summary>
/// Two dimensional array of transitions, indexed by state
/// number for traversal. The state numbering is consistent with
- /// <seealso cref="#runAutomaton"/>.
- /// Only valid for <seealso cref="AUTOMATON_TYPE#NORMAL"/>.
+ /// <see cref="RunAutomaton"/>.
+ /// <para/>
+ /// Only valid for <see cref="AUTOMATON_TYPE.NORMAL"/>.
/// </summary>
[WritableArray]
[SuppressMessage("Microsoft.Performance", "CA1819", Justification = "Lucene's design requires some writable array properties")]
@@ -97,7 +98,7 @@ namespace Lucene.Net.Util.Automaton
/// <summary>
/// Shared common suffix accepted by the automaton. Only valid
- /// for <seealso cref="AUTOMATON_TYPE#NORMAL"/>, and only when the
+ /// for <see cref="AUTOMATON_TYPE.NORMAL"/>, and only when the
/// automaton accepts an infinite language.
/// </summary>
public BytesRef CommonSuffixRef { get; private set; }
@@ -105,7 +106,7 @@ namespace Lucene.Net.Util.Automaton
/// <summary>
/// Indicates if the automaton accepts a finite set of strings.
/// Null if this was not computed.
- /// Only valid for <seealso cref="AUTOMATON_TYPE#NORMAL"/>.
+ /// Only valid for <see cref="AUTOMATON_TYPE.NORMAL"/>.
/// </summary>
public bool? Finite { get; private set; }
@@ -312,12 +313,12 @@ namespace Lucene.Net.Util.Automaton
/// <summary>
/// Finds largest term accepted by this Automaton, that's
- /// <= the provided input term. The result is placed in
- /// output; it's fine for output and input to point to
- /// the same BytesRef. The returned result is either the
- /// provided output, or null if there is no floor term
- /// (ie, the provided input term is before the first term
- /// accepted by this Automaton).
+ /// <= the provided input term. The result is placed in
+ /// output; it's fine for output and input to point to
+ /// the same <see cref="BytesRef"/>. The returned result is either the
+ /// provided output, or <c>null</c> if there is no floor term
+ /// (ie, the provided input term is before the first term
+ /// accepted by this <see cref="Automaton"/>).
/// </summary>
public virtual BytesRef Floor(BytesRef input, BytesRef output)
{
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9bd4dc81/src/Lucene.Net/Util/Automaton/DaciukMihovAutomatonBuilder.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Util/Automaton/DaciukMihovAutomatonBuilder.cs b/src/Lucene.Net/Util/Automaton/DaciukMihovAutomatonBuilder.cs
index 233dd62..5602c53 100644
--- a/src/Lucene.Net/Util/Automaton/DaciukMihovAutomatonBuilder.cs
+++ b/src/Lucene.Net/Util/Automaton/DaciukMihovAutomatonBuilder.cs
@@ -23,16 +23,16 @@ namespace Lucene.Net.Util.Automaton
*/
/// <summary>
- /// Builds a minimal, deterministic <seealso cref="Automaton"/> that accepts a set of
+ /// Builds a minimal, deterministic <see cref="Automaton"/> that accepts a set of
/// strings. The algorithm requires sorted input data, but is very fast
/// (nearly linear with the input size).
/// </summary>
- /// <seealso cref= #build(Collection) </seealso>
- /// <seealso cref= BasicAutomata#makeStringUnion(Collection) </seealso>
+ /// <seealso cref="Build(ICollection{BytesRef})"/>
+ /// <seealso cref="BasicAutomata.MakeStringUnion(ICollection{BytesRef})"/>
internal sealed class DaciukMihovAutomatonBuilder
{
/// <summary>
- /// DFSA state with <code>char</code> labels on transitions.
+ /// DFSA state with <see cref="char"/> labels on transitions.
/// </summary>
public sealed class State // LUCENENET NOTE: Made public because it is returned from a public member
{
@@ -45,27 +45,27 @@ namespace Lucene.Net.Util.Automaton
private static readonly State[] NO_STATES = new State[0];
/// <summary>
- /// Labels of outgoing transitions. Indexed identically to <seealso cref="#states"/>.
+ /// Labels of outgoing transitions. Indexed identically to <see cref="states"/>.
/// Labels must be sorted lexicographically.
/// </summary>
internal int[] labels = NO_LABELS;
/// <summary>
/// States reachable from outgoing transitions. Indexed identically to
- /// <seealso cref="#labels"/>.
+ /// <see cref="labels"/>.
/// </summary>
internal State[] states = NO_STATES;
/// <summary>
- /// <code>true</code> if this state corresponds to the end of at least one
+ /// <c>true</c> if this state corresponds to the end of at least one
/// input sequence.
/// </summary>
internal bool is_final;
/// <summary>
/// Returns the target state of a transition leaving this state and labeled
- /// with <code>label</code>. If no such transition exists, returns
- /// <code>null</code>.
+ /// with <paramref name="label"/>. If no such transition exists, returns
+ /// <c>null</c>.
/// </summary>
internal State GetState(int label)
{
@@ -75,12 +75,12 @@ namespace Lucene.Net.Util.Automaton
/// <summary>
/// Two states are equal if:
- /// <ul>
- /// <li>they have an identical number of outgoing transitions, labeled with
- /// the same labels</li>
- /// <li>corresponding outgoing transitions lead to the same states (to states
- /// with an identical right-language).
- /// </ul>
+ /// <list type="bullet">
+ /// <item><description>They have an identical number of outgoing transitions, labeled with
+ /// the same labels.</description></item>
+ /// <item><description>Corresponding outgoing transitions lead to the same states (to states
+ /// with an identical right-language).</description></item>
+ /// </list>
/// </summary>
public override bool Equals(object obj)
{
@@ -116,7 +116,7 @@ namespace Lucene.Net.Util.Automaton
}
/// <summary>
- /// Return <code>true</code> if this state has any children (outgoing
+ /// Return <c>true</c> if this state has any children (outgoing
/// transitions).
/// </summary>
internal bool HasChildren
@@ -125,7 +125,7 @@ namespace Lucene.Net.Util.Automaton
}
/// <summary>
- /// Create a new outgoing transition labeled <code>label</code> and return
+ /// Create a new outgoing transition labeled <paramref name="label"/> and return
/// the newly created target state for this transition.
/// </summary>
internal State NewState(int label)
@@ -150,7 +150,7 @@ namespace Lucene.Net.Util.Automaton
/// <summary>
/// Return the associated state if the most recent transition is labeled with
- /// <code>label</code>.
+ /// <paramref name="label"/>.
/// </summary>
internal State LastChild(int label)
{
@@ -166,7 +166,7 @@ namespace Lucene.Net.Util.Automaton
/// <summary>
/// Replace the last added outgoing transition's target state with the given
- /// state.
+ /// <paramref name="state"/>.
/// </summary>
internal void ReplaceLastChild(State state)
{
@@ -207,7 +207,7 @@ namespace Lucene.Net.Util.Automaton
private State root = new State();
/// <summary>
- /// Previous sequence added to the automaton in <seealso cref="#add(CharsRef)"/>.
+ /// Previous sequence added to the automaton in <see cref="Add(CharsRef)"/>.
/// </summary>
private CharsRef previous;
@@ -295,7 +295,7 @@ namespace Lucene.Net.Util.Automaton
}
/// <summary>
- /// Build a minimal, deterministic automaton from a sorted list of <seealso cref="BytesRef"/> representing
+ /// Build a minimal, deterministic automaton from a sorted list of <see cref="BytesRef"/> representing
/// strings in UTF-8. These strings must be binary-sorted.
/// </summary>
public static Automaton Build(ICollection<BytesRef> input)
@@ -316,7 +316,7 @@ namespace Lucene.Net.Util.Automaton
}
/// <summary>
- /// Copy <code>current</code> into an internal buffer.
+ /// Copy <paramref name="current"/> into an internal buffer.
/// </summary>
private bool SetPrevious(CharsRef current)
{
@@ -327,7 +327,7 @@ namespace Lucene.Net.Util.Automaton
}
/// <summary>
- /// Replace last child of <code>state</code> with an already registered state
+ /// Replace last child of <paramref name="state"/> with an already registered state
/// or stateRegistry the last child state.
/// </summary>
private void ReplaceOrRegister(State state)
@@ -351,8 +351,8 @@ namespace Lucene.Net.Util.Automaton
}
/// <summary>
- /// Add a suffix of <code>current</code> starting at <code>fromIndex</code>
- /// (inclusive) to state <code>state</code>.
+ /// Add a suffix of <paramref name="current"/> starting at <paramref name="fromIndex"/>
+ /// (inclusive) to state <paramref name="state"/>.
/// </summary>
private void AddSuffix(State state, ICharSequence current, int fromIndex)
{
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9bd4dc81/src/Lucene.Net/Util/Automaton/LevenshteinAutomata.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Util/Automaton/LevenshteinAutomata.cs b/src/Lucene.Net/Util/Automaton/LevenshteinAutomata.cs
index 9014336..f6e82f7 100644
--- a/src/Lucene.Net/Util/Automaton/LevenshteinAutomata.cs
+++ b/src/Lucene.Net/Util/Automaton/LevenshteinAutomata.cs
@@ -24,10 +24,10 @@ namespace Lucene.Net.Util.Automaton
/// <summary>
/// Class to construct DFAs that match a word within some edit distance.
- /// <p>
+ /// <para/>
/// Implements the algorithm described in:
/// Schulz and Mihov: Fast String Correction with Levenshtein Automata
- /// <p>
+ /// <para/>
/// @lucene.experimental
/// </summary>
public class LevenshteinAutomata
@@ -51,7 +51,7 @@ namespace Lucene.Net.Util.Automaton
internal ParametricDescription[] descriptions;
/// <summary>
- /// Create a new LevenshteinAutomata for some input String.
+ /// Create a new <see cref="LevenshteinAutomata"/> for some <paramref name="input"/> string.
/// Optionally count transpositions as a primitive edit.
/// </summary>
public LevenshteinAutomata(string input, bool withTranspositions)
@@ -61,7 +61,7 @@ namespace Lucene.Net.Util.Automaton
/// <summary>
/// Expert: specify a custom maximum possible symbol
- /// (alphaMax); default is Character.MAX_CODE_POINT.
+ /// (alphaMax); default is <see cref="Character.MAX_CODE_POINT"/>.
/// </summary>
public LevenshteinAutomata(int[] word, int alphaMax, bool withTranspositions)
{
@@ -130,15 +130,15 @@ namespace Lucene.Net.Util.Automaton
}
/// <summary>
- /// Compute a DFA that accepts all strings within an edit distance of <code>n</code>.
- /// <p>
+ /// Compute a DFA that accepts all strings within an edit distance of <paramref name="n"/>.
+ /// <para>
/// All automata have the following properties:
- /// <ul>
- /// <li>They are deterministic (DFA).
- /// <li>There are no transitions to dead states.
- /// <li>They are not minimal (some transitions could be combined).
- /// </ul>
- /// </p>
+ /// <list type="bullet">
+ /// <item><description>They are deterministic (DFA).</description></item>
+ /// <item><description>There are no transitions to dead states.</description></item>
+ /// <item><description>They are not minimal (some transitions could be combined).</description></item>
+ /// </list>
+ /// </para>
/// </summary>
public virtual Automaton ToAutomaton(int n)
{
@@ -211,8 +211,8 @@ namespace Lucene.Net.Util.Automaton
}
/// <summary>
- /// Get the characteristic vector <code>X(x, V)</code>
- /// where V is <code>substring(pos, end)</code>
+ /// Get the characteristic vector <c>X(x, V)</c>
+ /// where V is <c>Substring(pos, end - pos)</c>.
/// </summary>
internal virtual int GetVector(int x, int pos, int end)
{
@@ -229,16 +229,16 @@ namespace Lucene.Net.Util.Automaton
}
/// <summary>
- /// A ParametricDescription describes the structure of a Levenshtein DFA for some degree n.
- /// <p>
+ /// A <see cref="ParametricDescription"/> describes the structure of a Levenshtein DFA for some degree <c>n</c>.
+ /// <para/>
/// There are four components of a parametric description, all parameterized on the length
- /// of the word <code>w</code>:
- /// <ol>
- /// <li>The number of states: <seealso cref="#size()"/>
- /// <li>The set of final states: <seealso cref="#isAccept(int)"/>
- /// <li>The transition function: <seealso cref="#transition(int, int, int)"/>
- /// <li>Minimal boundary function: <seealso cref="#getPosition(int)"/>
- /// </ol>
+ /// of the word <c>w</c>:
+ /// <list type="number">
+ /// <item><description>The number of states: <see cref="Count"/></description></item>
+ /// <item><description>The set of final states: <see cref="IsAccept(int)"/></description></item>
+ /// <item><description>The transition function: <see cref="Transition(int, int, int)"/></description></item>
+ /// <item><description>Minimal boundary function: <see cref="GetPosition(int)"/></description></item>
+ /// </list>
/// </summary>
internal abstract class ParametricDescription
{
@@ -255,6 +255,7 @@ namespace Lucene.Net.Util.Automaton
/// <summary>
/// Return the number of states needed to compute a Levenshtein DFA.
+ /// <para/>
/// NOTE: This was size() in Lucene.
/// </summary>
internal virtual int Count
@@ -263,7 +264,7 @@ namespace Lucene.Net.Util.Automaton
}
/// <summary>
- /// Returns true if the <code>state</code> in any Levenshtein DFA is an accept state (final state).
+ /// Returns <c>true</c> if the <c>state</c> in any Levenshtein DFA is an accept state (final state).
/// </summary>
internal virtual bool IsAccept(int absState)
{
@@ -275,7 +276,7 @@ namespace Lucene.Net.Util.Automaton
}
/// <summary>
- /// Returns the position in the input word for a given <code>state</code>.
+ /// Returns the position in the input word for a given <c>state</c>.
/// this is the minimal boundary for the state.
/// </summary>
internal virtual int GetPosition(int absState)
@@ -284,8 +285,8 @@ namespace Lucene.Net.Util.Automaton
}
/// <summary>
- /// Returns the state number for a transition from the given <code>state</code>,
- /// assuming <code>position</code> and characteristic vector <code>vector</code>
+ /// Returns the state number for a transition from the given <paramref name="state"/>,
+ /// assuming <paramref name="position"/> and characteristic vector <paramref name="vector"/>.
/// </summary>
internal abstract int Transition(int state, int position, int vector);
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9bd4dc81/src/Lucene.Net/Util/Automaton/MinimizationOperations.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Util/Automaton/MinimizationOperations.cs b/src/Lucene.Net/Util/Automaton/MinimizationOperations.cs
index 4555f70..2d4490b 100644
--- a/src/Lucene.Net/Util/Automaton/MinimizationOperations.cs
+++ b/src/Lucene.Net/Util/Automaton/MinimizationOperations.cs
@@ -35,7 +35,7 @@ namespace Lucene.Net.Util.Automaton
{
/// <summary>
/// Operations for minimizing automata.
- ///
+ /// <para/>
/// @lucene.experimental
/// </summary>
internal sealed class MinimizationOperations
@@ -48,7 +48,7 @@ namespace Lucene.Net.Util.Automaton
/// Minimizes (and determinizes if not already deterministic) the given
/// automaton.
/// </summary>
- /// <seealso cref= Automaton#setMinimization(int) </seealso>
+ /// <seealso cref="Automaton.SetMinimization(int)"/>
public static void Minimize(Automaton a)
{
if (!a.IsSingleton)
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9bd4dc81/src/Lucene.Net/Util/Automaton/RegExp.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Util/Automaton/RegExp.cs b/src/Lucene.Net/Util/Automaton/RegExp.cs
index 1bfe383..a6b5242 100644
--- a/src/Lucene.Net/Util/Automaton/RegExp.cs
+++ b/src/Lucene.Net/Util/Automaton/RegExp.cs
@@ -83,281 +83,283 @@ namespace Lucene.Net.Util.Automaton
/// <summary>
- /// Regular Expression extension to <code>Automaton</code>.
- /// <p>
+ /// Regular Expression extension to <see cref="Util.Automaton.Automaton"/>.
+ /// <para/>
/// Regular expressions are built from the following abstract syntax:
- /// <p>
- /// <table border=0>
- /// <tr>
- /// <td><i>regexp</i></td>
- /// <td>::=</td>
- /// <td><i>unionexp</i></td>
- /// <td></td>
- /// <td></td>
- /// </tr>
- /// <tr>
- /// <td></td>
- /// <td>|</td>
- /// <td></td>
- /// <td></td>
- /// <td></td>
- /// </tr>
- ///
- /// <tr>
- /// <td><i>unionexp</i></td>
- /// <td>::=</td>
- /// <td><i>interexp</i> <tt><b>|</b></tt> <i>unionexp</i></td>
- /// <td>(union)</td>
- /// <td></td>
- /// </tr>
- /// <tr>
- /// <td></td>
- /// <td>|</td>
- /// <td><i>interexp</i></td>
- /// <td></td>
- /// <td></td>
- /// </tr>
- ///
- /// <tr>
- /// <td><i>interexp</i></td>
- /// <td>::=</td>
- /// <td><i>concatexp</i> <tt><b>&</b></tt> <i>interexp</i></td>
- /// <td>(intersection)</td>
- /// <td><small>[OPTIONAL]</small></td>
- /// </tr>
- /// <tr>
- /// <td></td>
- /// <td>|</td>
- /// <td><i>concatexp</i></td>
- /// <td></td>
- /// <td></td>
- /// </tr>
- ///
- /// <tr>
- /// <td><i>concatexp</i></td>
- /// <td>::=</td>
- /// <td><i>repeatexp</i> <i>concatexp</i></td>
- /// <td>(concatenation)</td>
- /// <td></td>
- /// </tr>
- /// <tr>
- /// <td></td>
- /// <td>|</td>
- /// <td><i>repeatexp</i></td>
- /// <td></td>
- /// <td></td>
- /// </tr>
- ///
- /// <tr>
- /// <td><i>repeatexp</i></td>
- /// <td>::=</td>
- /// <td><i>repeatexp</i> <tt><b>?</b></tt></td>
- /// <td>(zero or one occurrence)</td>
- /// <td></td>
- /// </tr>
- /// <tr>
- /// <td></td>
- /// <td>|</td>
- /// <td><i>repeatexp</i> <tt><b>*</b></tt></td>
- /// <td>(zero or more occurrences)</td>
- /// <td></td>
- /// </tr>
- /// <tr>
- /// <td></td>
- /// <td>|</td>
- /// <td><i>repeatexp</i> <tt><b>+</b></tt></td>
- /// <td>(one or more occurrences)</td>
- /// <td></td>
- /// </tr>
- /// <tr>
- /// <td></td>
- /// <td>|</td>
- /// <td><i>repeatexp</i> <tt><b>{</b><i>n</i><b>}</b></tt></td>
- /// <td>(<tt><i>n</i></tt> occurrences)</td>
- /// <td></td>
- /// </tr>
- /// <tr>
- /// <td></td>
- /// <td>|</td>
- /// <td><i>repeatexp</i> <tt><b>{</b><i>n</i><b>,}</b></tt></td>
- /// <td>(<tt><i>n</i></tt> or more occurrences)</td>
- /// <td></td>
- /// </tr>
- /// <tr>
- /// <td></td>
- /// <td>|</td>
- /// <td><i>repeatexp</i> <tt><b>{</b><i>n</i><b>,</b><i>m</i><b>}</b></tt></td>
- /// <td>(<tt><i>n</i></tt> to <tt><i>m</i></tt> occurrences, including both)</td>
- /// <td></td>
- /// </tr>
- /// <tr>
- /// <td></td>
- /// <td>|</td>
- /// <td><i>complexp</i></td>
- /// <td></td>
- /// <td></td>
- /// </tr>
- ///
- /// <tr>
- /// <td><i>complexp</i></td>
- /// <td>::=</td>
- /// <td><tt><b>~</b></tt> <i>complexp</i></td>
- /// <td>(complement)</td>
- /// <td><small>[OPTIONAL]</small></td>
- /// </tr>
- /// <tr>
- /// <td></td>
- /// <td>|</td>
- /// <td><i>charclassexp</i></td>
- /// <td></td>
- /// <td></td>
- /// </tr>
- ///
- /// <tr>
- /// <td><i>charclassexp</i></td>
- /// <td>::=</td>
- /// <td><tt><b>[</b></tt> <i>charclasses</i> <tt><b>]</b></tt></td>
- /// <td>(character class)</td>
- /// <td></td>
- /// </tr>
- /// <tr>
- /// <td></td>
- /// <td>|</td>
- /// <td><tt><b>[^</b></tt> <i>charclasses</i> <tt><b>]</b></tt></td>
- /// <td>(negated character class)</td>
- /// <td></td>
- /// </tr>
- /// <tr>
- /// <td></td>
- /// <td>|</td>
- /// <td><i>simpleexp</i></td>
- /// <td></td>
- /// <td></td>
- /// </tr>
- ///
- /// <tr>
- /// <td><i>charclasses</i></td>
- /// <td>::=</td>
- /// <td><i>charclass</i> <i>charclasses</i></td>
- /// <td></td>
- /// <td></td>
- /// </tr>
- /// <tr>
- /// <td></td>
- /// <td>|</td>
- /// <td><i>charclass</i></td>
- /// <td></td>
- /// <td></td>
- /// </tr>
- ///
- /// <tr>
- /// <td><i>charclass</i></td>
- /// <td>::=</td>
- /// <td><i>charexp</i> <tt><b>-</b></tt> <i>charexp</i></td>
- /// <td>(character range, including end-points)</td>
- /// <td></td>
- /// </tr>
- /// <tr>
- /// <td></td>
- /// <td>|</td>
- /// <td><i>charexp</i></td>
- /// <td></td>
- /// <td></td>
- /// </tr>
- ///
- /// <tr>
- /// <td><i>simpleexp</i></td>
- /// <td>::=</td>
- /// <td><i>charexp</i></td>
- /// <td></td>
- /// <td></td>
- /// </tr>
- /// <tr>
- /// <td></td>
- /// <td>|</td>
- /// <td><tt><b>.</b></tt></td>
- /// <td>(any single character)</td>
- /// <td></td>
- /// </tr>
- /// <tr>
- /// <td></td>
- /// <td>|</td>
- /// <td><tt><b>#</b></tt></td>
- /// <td>(the empty language)</td>
- /// <td><small>[OPTIONAL]</small></td>
- /// </tr>
- /// <tr>
- /// <td></td>
- /// <td>|</td>
- /// <td><tt><b>@</b></tt></td>
- /// <td>(any string)</td>
- /// <td><small>[OPTIONAL]</small></td>
- /// </tr>
- /// <tr>
- /// <td></td>
- /// <td>|</td>
- /// <td><tt><b>"</b></tt> <Unicode string without double-quotes> <tt><b>"</b></tt></td>
- /// <td>(a string)</td>
- /// <td></td>
- /// </tr>
- /// <tr>
- /// <td></td>
- /// <td>|</td>
- /// <td><tt><b>(</b></tt> <tt><b>)</b></tt></td>
- /// <td>(the empty string)</td>
- /// <td></td>
- /// </tr>
- /// <tr>
- /// <td></td>
- /// <td>|</td>
- /// <td><tt><b>(</b></tt> <i>unionexp</i> <tt><b>)</b></tt></td>
- /// <td>(precedence override)</td>
- /// <td></td>
- /// </tr>
- /// <tr>
- /// <td></td>
- /// <td>|</td>
- /// <td><tt><b><</b></tt> <identifier> <tt><b>></b></tt></td>
- /// <td>(named automaton)</td>
- /// <td><small>[OPTIONAL]</small></td>
- /// </tr>
- /// <tr>
- /// <td></td>
- /// <td>|</td>
- /// <td><tt><b><</b><i>n</i>-<i>m</i><b>></b></tt></td>
- /// <td>(numerical interval)</td>
- /// <td><small>[OPTIONAL]</small></td>
- /// </tr>
- ///
- /// <tr>
- /// <td><i>charexp</i></td>
- /// <td>::=</td>
- /// <td><Unicode character></td>
- /// <td>(a single non-reserved character)</td>
- /// <td></td>
- /// </tr>
- /// <tr>
- /// <td></td>
- /// <td>|</td>
- /// <td><tt><b>\</b></tt> <Unicode character> </td>
- /// <td>(a single character)</td>
- /// <td></td>
- /// </tr>
- /// </table>
- /// <p>
+ /// <para/>
+ /// <list type="table">
+ /// <item>
+ /// <term><i>regexp</i></term>
+ /// <term>::=</term>
+ /// <term><i>unionexp</i></term>
+ /// <term></term>
+ /// <term></term>
+ /// </item>
+ /// <item>
+ /// <term></term>
+ /// <term>|</term>
+ /// <term></term>
+ /// <term></term>
+ /// <term></term>
+ /// </item>
+ ///
+ /// <item>
+ /// <term><i>unionexp</i></term>
+ /// <term>::=</term>
+ /// <term><i>interexp</i> <tt><b>|</b></tt> <i>unionexp</i></term>
+ /// <term>(union)</term>
+ /// <term></term>
+ /// </item>
+ /// <item>
+ /// <term></term>
+ /// <term>|</term>
+ /// <term><i>interexp</i></term>
+ /// <term></term>
+ /// <term></term>
+ /// </item>
+ ///
+ /// <item>
+ /// <term><i>interexp</i></term>
+ /// <term>::=</term>
+ /// <term><i>concatexp</i> <tt><b>&</b></tt> <i>interexp</i></term>
+ /// <term>(intersection)</term>
+ /// <term><small>[OPTIONAL]</small></term>
+ /// </item>
+ /// <item>
+ /// <term></term>
+ /// <term>|</term>
+ /// <term><i>concatexp</i></term>
+ /// <term></term>
+ /// <term></term>
+ /// </item>
+ ///
+ /// <item>
+ /// <term><i>concatexp</i></term>
+ /// <term>::=</term>
+ /// <term><i>repeatexp</i> <i>concatexp</i></term>
+ /// <term>(concatenation)</term>
+ /// <term></term>
+ /// </item>
+ /// <item>
+ /// <term></term>
+ /// <term>|</term>
+ /// <term><i>repeatexp</i></term>
+ /// <term></term>
+ /// <term></term>
+ /// </item>
+ ///
+ /// <item>
+ /// <term><i>repeatexp</i></term>
+ /// <term>::=</term>
+ /// <term><i>repeatexp</i> <tt><b>?</b></tt></term>
+ /// <term>(zero or one occurrence)</term>
+ /// <term></term>
+ /// </item>
+ /// <item>
+ /// <term></term>
+ /// <term>|</term>
+ /// <term><i>repeatexp</i> <tt><b>*</b></tt></term>
+ /// <term>(zero or more occurrences)</term>
+ /// <term></term>
+ /// </item>
+ /// <item>
+ /// <term></term>
+ /// <term>|</term>
+ /// <term><i>repeatexp</i> <tt><b>+</b></tt></term>
+ /// <term>(one or more occurrences)</term>
+ /// <term></term>
+ /// </item>
+ /// <item>
+ /// <term></term>
+ /// <term>|</term>
+ /// <term><i>repeatexp</i> <tt><b>{</b><i>n</i><b>}</b></tt></term>
+ /// <term>(<tt><i>n</i></tt> occurrences)</term>
+ /// <term></term>
+ /// </item>
+ /// <item>
+ /// <term></term>
+ /// <term>|</term>
+ /// <term><i>repeatexp</i> <tt><b>{</b><i>n</i><b>,}</b></tt></term>
+ /// <term>(<tt><i>n</i></tt> or more occurrences)</term>
+ /// <term></term>
+ /// </item>
+ /// <item>
+ /// <term></term>
+ /// <term>|</term>
+ /// <term><i>repeatexp</i> <tt><b>{</b><i>n</i><b>,</b><i>m</i><b>}</b></tt></term>
+ /// <term>(<tt><i>n</i></tt> to <tt><i>m</i></tt> occurrences, including both)</term>
+ /// <term></term>
+ /// </item>
+ /// <item>
+ /// <term></term>
+ /// <term>|</term>
+ /// <term><i>complexp</i></term>
+ /// <term></term>
+ /// <term></term>
+ /// </item>
+ ///
+ /// <item>
+ /// <term><i>complexp</i></term>
+ /// <term>::=</term>
+ /// <term><tt><b>~</b></tt> <i>complexp</i></term>
+ /// <term>(complement)</term>
+ /// <term><small>[OPTIONAL]</small></term>
+ /// </item>
+ /// <item>
+ /// <term></term>
+ /// <term>|</term>
+ /// <term><i>charclassexp</i></term>
+ /// <term></term>
+ /// <term></term>
+ /// </item>
+ ///
+ /// <item>
+ /// <term><i>charclassexp</i></term>
+ /// <term>::=</term>
+ /// <term><tt><b>[</b></tt> <i>charclasses</i> <tt><b>]</b></tt></term>
+ /// <term>(character class)</term>
+ /// <term></term>
+ /// </item>
+ /// <item>
+ /// <term></term>
+ /// <term>|</term>
+ /// <term><tt><b>[^</b></tt> <i>charclasses</i> <tt><b>]</b></tt></term>
+ /// <term>(negated character class)</term>
+ /// <term></term>
+ /// </item>
+ /// <item>
+ /// <term></term>
+ /// <term>|</term>
+ /// <term><i>simpleexp</i></term>
+ /// <term></term>
+ /// <term></term>
+ /// </item>
+ ///
+ /// <item>
+ /// <term><i>charclasses</i></term>
+ /// <term>::=</term>
+ /// <term><i>charclass</i> <i>charclasses</i></term>
+ /// <term></term>
+ /// <term></term>
+ /// </item>
+ /// <item>
+ /// <term></term>
+ /// <term>|</term>
+ /// <term><i>charclass</i></term>
+ /// <term></term>
+ /// <term></term>
+ /// </item>
+ ///
+ /// <item>
+ /// <term><i>charclass</i></term>
+ /// <term>::=</term>
+ /// <term><i>charexp</i> <tt><b>-</b></tt> <i>charexp</i></term>
+ /// <term>(character range, including end-points)</term>
+ /// <term></term>
+ /// </item>
+ /// <item>
+ /// <term></term>
+ /// <term>|</term>
+ /// <term><i>charexp</i></term>
+ /// <term></term>
+ /// <term></term>
+ /// </item>
+ ///
+ /// <item>
+ /// <term><i>simpleexp</i></term>
+ /// <term>::=</term>
+ /// <term><i>charexp</i></term>
+ /// <term></term>
+ /// <term></term>
+ /// </item>
+ /// <item>
+ /// <term></term>
+ /// <term>|</term>
+ /// <term><tt><b>.</b></tt></term>
+ /// <term>(any single character)</term>
+ /// <term></term>
+ /// </item>
+ /// <item>
+ /// <term></term>
+ /// <term>|</term>
+ /// <term><tt><b>#</b></tt></term>
+ /// <term>(the empty language)</term>
+ /// <term><small>[OPTIONAL]</small></term>
+ /// </item>
+ /// <item>
+ /// <term></term>
+ /// <term>|</term>
+ /// <term><tt><b>@</b></tt></term>
+ /// <term>(any string)</term>
+ /// <term><small>[OPTIONAL]</small></term>
+ /// </item>
+ /// <item>
+ /// <term></term>
+ /// <term>|</term>
+ /// <term><tt><b>"</b></tt> <Unicode string without double-quotes>  <tt><b>"</b></tt></term>
+ /// <term>(a string)</term>
+ /// <term></term>
+ /// </item>
+ /// <item>
+ /// <term></term>
+ /// <term>|</term>
+ /// <term><tt><b>(</b></tt> <tt><b>)</b></tt></term>
+ /// <term>(the empty string)</term>
+ /// <term></term>
+ /// </item>
+ /// <item>
+ /// <term></term>
+ /// <term>|</term>
+ /// <term><tt><b>(</b></tt> <i>unionexp</i> <tt><b>)</b></tt></term>
+ /// <term>(precedence override)</term>
+ /// <term></term>
+ /// </item>
+ /// <item>
+ /// <term></term>
+ /// <term>|</term>
+ /// <term><tt><b><</b></tt> <identifier> <tt><b>></b></tt></term>
+ /// <term>(named automaton)</term>
+ /// <term><small>[OPTIONAL]</small></term>
+ /// </item>
+ /// <item>
+ /// <term></term>
+ /// <term>|</term>
+ /// <term><tt><b><</b><i>n</i>-<i>m</i><b>></b></tt></term>
+ /// <term>(numerical interval)</term>
+ /// <term><small>[OPTIONAL]</small></term>
+ /// </item>
+ ///
+ /// <item>
+ /// <term><i>charexp</i></term>
+ /// <term>::=</term>
+ /// <term><Unicode character></term>
+ /// <term>(a single non-reserved character)</term>
+ /// <term></term>
+ /// </item>
+ /// <item>
+ /// <term></term>
+ /// <term>|</term>
+ /// <term><tt><b>\</b></tt> <Unicode character> </term>
+ /// <term>(a single character)</term>
+ /// <term></term>
+ /// </item>
+ ///
+ /// </list>
+ ///
+ /// <para/>
/// The productions marked <small>[OPTIONAL]</small> are only allowed if
- /// specified by the syntax flags passed to the <code>RegExp</code> constructor.
+ /// specified by the syntax flags passed to the <see cref="RegExp"/> constructor.
/// The reserved characters used in the (enabled) syntax must be escaped with
- /// backslash (<tt><b>\</b></tt>) or double-quotes (<tt><b>"..."</b></tt>). (In
+ /// backslash (<c>\</c>) or double-quotes (<c>"..."</c>). (In
/// contrast to other regexp syntaxes, this is required also in character
- /// classes.) Be aware that dash (<tt><b>-</b></tt>) has a special meaning in
+ /// classes.) Be aware that dash (<c>-</c>) has a special meaning in
/// <i>charclass</i> expressions. An identifier is a string not containing right
- /// angle bracket (<tt><b>></b></tt>) or dash (<tt><b>-</b></tt>). Numerical
+ /// angle bracket (<c>></c>) or dash (<c>-</c>). Numerical
/// intervals are specified by non-negative decimal integers and include both end
- /// points, and if <tt><i>n</i></tt> and <tt><i>m</i></tt> have the same number
+ /// points, and if <c>n</c> and <c>m</c> have the same number
/// of digits, then the conforming strings must have that length (i.e. prefixed
/// by 0's).
- ///
+ /// <para/>
/// @lucene.experimental
/// </summary>
public class RegExp
@@ -406,9 +408,9 @@ namespace Lucene.Net.Util.Automaton
/// Constructs new <see cref="RegExp"/> from a string. Same as
/// <c>RegExp(s, RegExpSyntax.ALL)</c>.
/// </summary>
- /// <param name="s"> regexp string </param>
- /// <exception cref="ArgumentException"> if an error occured while parsing the
- /// regular expression </exception>
+ /// <param name="s"> Regexp string. </param>
+ /// <exception cref="ArgumentException"> If an error occured while parsing the
+ /// regular expression. </exception>
public RegExp(string s)
: this(s, RegExpSyntax.ALL)
{
@@ -417,10 +419,10 @@ namespace Lucene.Net.Util.Automaton
/// <summary>
/// Constructs new <see cref="RegExp"/> from a string.
/// </summary>
- /// <param name="s"> regexp string </param>
- /// <param name="syntax_flags"> boolean 'or' of optional <see cref="RegExpSyntax"/> constructs to be
- /// enabled </param>
- /// <exception cref="ArgumentException"> if an error occured while parsing the
+ /// <param name="s"> Regexp string. </param>
+ /// <param name="syntax_flags"> Boolean 'or' of optional <see cref="RegExpSyntax"/> constructs to be
+ /// enabled. </param>
+ /// <exception cref="ArgumentException"> If an error occured while parsing the
/// regular expression </exception>
public RegExp(string s, RegExpSyntax syntax_flags)
{
@@ -453,8 +455,8 @@ namespace Lucene.Net.Util.Automaton
}
/// <summary>
- /// Constructs new <code>Automaton</code> from this <code>RegExp</code>. Same
- /// as <code>toAutomaton(null)</code> (empty automaton map).
+ /// Constructs new <see cref="Automaton"/> from this <see cref="RegExp"/>. Same
+ /// as <c>ToAutomaton(null)</c> (empty automaton map).
/// </summary>
public virtual Automaton ToAutomaton()
{
@@ -462,27 +464,27 @@ namespace Lucene.Net.Util.Automaton
}
/// <summary>
- /// Constructs new <code>Automaton</code> from this <code>RegExp</code>. The
+ /// Constructs new <see cref="Automaton"/> from this <see cref="RegExp"/>. The
/// constructed automaton is minimal and deterministic and has no transitions
/// to dead states.
/// </summary>
- /// <param name="automaton_provider"> provider of automata for named identifiers </param>
- /// <exception cref="IllegalArgumentException"> if this regular expression uses a named
- /// identifier that is not available from the automaton provider </exception>
+ /// <param name="automaton_provider"> Provider of automata for named identifiers. </param>
+ /// <exception cref="ArgumentException"> If this regular expression uses a named
+ /// identifier that is not available from the automaton provider. </exception>
public virtual Automaton ToAutomaton(IAutomatonProvider automaton_provider)
{
return ToAutomatonAllowMutate(null, automaton_provider);
}
/// <summary>
- /// Constructs new <code>Automaton</code> from this <code>RegExp</code>. The
+ /// Constructs new <see cref="Automaton"/> from this <see cref="RegExp"/>. The
/// constructed automaton is minimal and deterministic and has no transitions
/// to dead states.
/// </summary>
- /// <param name="automata"> a map from automaton identifiers to automata (of type
- /// <code>Automaton</code>). </param>
- /// <exception cref="IllegalArgumentException"> if this regular expression uses a named
- /// identifier that does not occur in the automaton map </exception>
+ /// <param name="automata"> A map from automaton identifiers to automata (of type
+ /// <see cref="Automaton"/>). </param>
+ /// <exception cref="ArgumentException"> If this regular expression uses a named
+ /// identifier that does not occur in the automaton map. </exception>
public virtual Automaton ToAutomaton(IDictionary<string, Automaton> automata)
{
return ToAutomatonAllowMutate(automata, null);
@@ -493,8 +495,8 @@ namespace Lucene.Net.Util.Automaton
/// construction uses mutable automata, which is slightly faster but not thread
/// safe. By default, the flag is not set.
/// </summary>
- /// <param name="flag"> if true, the flag is set </param>
- /// <returns> previous value of the flag </returns>
+ /// <param name="flag"> If <c>true</c>, the flag is set </param>
+ /// <returns> Previous value of the flag. </returns>
public virtual bool SetAllowMutate(bool flag)
{
bool b = allow_mutation;
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9bd4dc81/src/Lucene.Net/Util/Automaton/RunAutomaton.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Util/Automaton/RunAutomaton.cs b/src/Lucene.Net/Util/Automaton/RunAutomaton.cs
index 7359c1f..509b526 100644
--- a/src/Lucene.Net/Util/Automaton/RunAutomaton.cs
+++ b/src/Lucene.Net/Util/Automaton/RunAutomaton.cs
@@ -35,7 +35,7 @@ namespace Lucene.Net.Util.Automaton
{
/// <summary>
/// Finite-state automaton with fast run operation.
- ///
+ /// <para/>
/// @lucene.experimental
/// </summary>
public abstract class RunAutomaton
@@ -100,6 +100,7 @@ namespace Lucene.Net.Util.Automaton
/// <summary>
/// Returns number of states in automaton.
+ /// <para/>
/// NOTE: This was size() in Lucene.
/// </summary>
public int Count
@@ -139,7 +140,7 @@ namespace Lucene.Net.Util.Automaton
}
/// <summary>
- /// Gets character class of given codepoint
+ /// Gets character class of given codepoint.
/// </summary>
internal int GetCharClass(int c)
{
@@ -147,10 +148,10 @@ namespace Lucene.Net.Util.Automaton
}
/// <summary>
- /// Constructs a new <code>RunAutomaton</code> from a deterministic
- /// <code>Automaton</code>.
+ /// Constructs a new <see cref="RunAutomaton"/> from a deterministic
+ /// <see cref="Automaton"/>.
/// </summary>
- /// <param name="a"> an automaton </param>
+ /// <param name="a"> An automaton. </param>
/// <param name="maxInterval"></param>
/// <param name="tableize"></param>
public RunAutomaton(Automaton a, int maxInterval, bool tableize)
@@ -205,7 +206,7 @@ namespace Lucene.Net.Util.Automaton
/// <summary>
/// Returns the state obtained by reading the given char from the given state.
/// Returns -1 if not obtaining any such state. (If the original
- /// <code>Automaton</code> had no dead states, -1 is returned here if and only
+ /// <see cref="Automaton"/> had no dead states, -1 is returned here if and only
/// if a dead state is entered in an equivalent automaton with a total
/// transition function.)
/// </summary>
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/9bd4dc81/src/Lucene.Net/Util/Automaton/SortedIntSet.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Util/Automaton/SortedIntSet.cs b/src/Lucene.Net/Util/Automaton/SortedIntSet.cs
index 7412746..97258f5 100644
--- a/src/Lucene.Net/Util/Automaton/SortedIntSet.cs
+++ b/src/Lucene.Net/Util/Automaton/SortedIntSet.cs
@@ -23,9 +23,9 @@ namespace Lucene.Net.Util.Automaton
*/
/// <summary>
- /// Just holds a set of int[] states, plus a corresponding
- /// int[] count per state. Used by
- /// BasicOperations.determinize
+ /// Just holds a set of <see cref="T:int[]"/> states, plus a corresponding
+ /// <see cref="T:int[]"/> count per state. Used by
+ /// <see cref="BasicOperations.Determinize(Automaton)"/>.
/// <para/>
/// NOTE: This was SortedIntSet in Lucene
/// </summary>