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 <[email protected]> Authored: Mon Jun 5 02:26:30 2017 +0700 Committer: Shad Storhaug <[email protected]> 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>
