lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From nightowl...@apache.org
Subject [39/58] lucenenet git commit: QueryParser.Flexible: Documentation comments
Date Tue, 06 Dec 2016 15:12:14 GMT
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/Token.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/Token.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/Token.cs
index 5a59a3b..a5ed823 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/Token.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/Token.cs
@@ -25,106 +25,106 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Parser
     [Serializable]
     public class Token
     {
-        /**
-         * An integer that describes the kind of this token.  This numbering
-         * system is determined by JavaCCParser, and a table of these numbers is
-         * stored in the file ...Constants.java.
-         */
+        /// <summary>
+        /// An integer that describes the kind of this token.  This numbering
+        /// system is determined by JavaCCParser, and a table of these numbers is
+        /// stored in the file ...Constants.java.
+        /// </summary>
         public int kind;
 
-        /** The line number of the first character of this Token. */
+        /// <summary>The line number of the first character of this Token.</summary>
         public int beginLine;
-        /** The column number of the first character of this Token. */
+        /// <summary>The column number of the first character of this Token.</summary>
         public int beginColumn;
-        /** The line number of the last character of this Token. */
+        /// <summary>The line number of the last character of this Token.</summary>
         public int endLine;
-        /** The column number of the last character of this Token. */
+        /// <summary>The column number of the last character of this Token.</summary>
         public int endColumn;
 
-        /**
-         * The string image of the token.
-         */
+        /// <summary>
+        /// The string image of the token.
+        /// </summary>
         public string image;
 
-        /**
-         * A reference to the next regular (non-special) token from the input
-         * stream.  If this is the last token from the input stream, or if the
-         * token manager has not read tokens beyond this one, this field is
-         * set to null.  This is true only if this token is also a regular
-         * token.  Otherwise, see below for a description of the contents of
-         * this field.
-         */
+        /// <summary>
+        /// A reference to the next regular (non-special) token from the input
+        /// stream.  If this is the last token from the input stream, or if the
+        /// token manager has not read tokens beyond this one, this field is
+        /// set to null.  This is true only if this token is also a regular
+        /// token.  Otherwise, see below for a description of the contents of
+        /// this field.
+        /// </summary>
         public Token next;
 
-        /**
-         * This field is used to access special tokens that occur prior to this
-         * token, but after the immediately preceding regular (non-special) token.
-         * If there are no such special tokens, this field is set to null.
-         * When there are more than one such special token, this field refers
-         * to the last of these special tokens, which in turn refers to the next
-         * previous special token through its specialToken field, and so on
-         * until the first special token (whose specialToken field is null).
-         * The next fields of special tokens refer to other special tokens that
-         * immediately follow it (without an intervening regular token).  If there
-         * is no such token, this field is null.
-         */
+        /// <summary>
+        /// This field is used to access special tokens that occur prior to this
+        /// token, but after the immediately preceding regular (non-special) token.
+        /// If there are no such special tokens, this field is set to null.
+        /// When there are more than one such special token, this field refers
+        /// to the last of these special tokens, which in turn refers to the next
+        /// previous special token through its specialToken field, and so on
+        /// until the first special token (whose specialToken field is null).
+        /// The next fields of special tokens refer to other special tokens that
+        /// immediately follow it (without an intervening regular token).  If there
+        /// is no such token, this field is null.
+        /// </summary>
         public Token specialToken;
 
-        /**
-         * An optional attribute value of the Token.
-         * Tokens which are not used as syntactic sugar will often contain
-         * meaningful values that will be used later on by the compiler or
-         * interpreter. This attribute value is often different from the image.
-         * Any subclass of Token that actually wants to return a non-null value can
-         * override this method as appropriate.
-         */
+        /// <summary>
+        /// An optional attribute value of the Token.
+        /// Tokens which are not used as syntactic sugar will often contain
+        /// meaningful values that will be used later on by the compiler or
+        /// interpreter. This attribute value is often different from the image.
+        /// Any subclass of Token that actually wants to return a non-null value can
+        /// override this method as appropriate.
+        /// </summary>
         public virtual object Value
         {
             get { return null; }
         }
 
-        /**
-         * No-argument constructor
-         */
+        /// <summary>
+        /// No-argument constructor
+        /// </summary>
         public Token() { }
 
-        /**
-         * Constructs a new token for the specified Image.
-         */
+        /// <summary>
+        /// Constructs a new token for the specified Image.
+        /// </summary>
         public Token(int kind)
             : this(kind, null)
         {
         }
 
-        /**
-         * Constructs a new token for the specified Image and Kind.
-         */
+        /// <summary>
+        /// Constructs a new token for the specified Image and Kind.
+        /// </summary>
         public Token(int kind, string image)
         {
             this.kind = kind;
             this.image = image;
         }
 
-        /**
-         * Returns the image.
-         */
+        /// <summary>
+        /// Returns the image.
+        /// </summary>
         public override string ToString()
         {
             return image;
         }
 
-        /**
-         * Returns a new Token object, by default. However, if you want, you
-         * can create and return subclass objects based on the value of ofKind.
-         * Simply add the cases to the switch for all those special cases.
-         * For example, if you have a subclass of Token called IDToken that
-         * you want to create if ofKind is ID, simply add something like :
-         *
-         *    case MyParserConstants.ID : return new IDToken(ofKind, image);
-         *
-         * to the following switch statement. Then you can cast matchedToken
-         * variable to the appropriate type and use sit in your lexical actions.
-         */
+        /// <summary>
+        /// Returns a new <see cref="Token"/> object, by default. However, if you want, you
+        /// can create and return subclass objects based on the value of <paramref name="ofKind"/>.
+        /// Simply add the cases to the switch for all those special cases.
+        /// For example, if you have a subclass of <see cref="Token"/> called IDToken that
+        /// you want to create if <paramref name="ofKind"/> is ID, simply add something like :
+        /// <code>
+        ///     case MyParserConstants.ID : return new IDToken(ofKind, image);
+        /// </code>
+        /// to the following switch statement. Then you can cast matchedToken
+        /// variable to the appropriate type and use sit in your lexical actions.
+        /// </summary>
         public static Token NewToken(int ofKind, string image)
         {
             switch (ofKind)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/TokenMgrError.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/TokenMgrError.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/TokenMgrError.cs
index 2d29471..329410d 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/TokenMgrError.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Parser/TokenMgrError.cs
@@ -27,40 +27,38 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Parser
     [Serializable]
     public class TokenMgrError : Exception
     {
-        /*
-         * Ordinals for various reasons why an Error of this type can be thrown.
-         */
+        // Ordinals for various reasons why an Error of this type can be thrown.
 
-        /**
-         * Lexical error occurred.
-         */
+        /// <summary>
+        /// Lexical error occurred.
+        /// </summary>
         internal static readonly int LEXICAL_ERROR = 0;
 
-        /**
-         * An attempt was made to create a second instance of a static token manager.
-         */
+        /// <summary>
+        /// An attempt was made to create a second instance of a static token manager.
+        /// </summary>
         internal static readonly int STATIC_LEXER_ERROR = 1;
 
-        /**
-         * Tried to change to an invalid lexical state.
-         */
+        /// <summary>
+        /// Tried to change to an invalid lexical state.
+        /// </summary>
         internal static readonly int INVALID_LEXICAL_STATE = 2;
 
-        /**
-         * Detected (and bailed out of) an infinite loop in the token manager.
-         */
+        /// <summary>
+        /// Detected (and bailed out of) an infinite loop in the token manager.
+        /// </summary>
         internal static readonly int LOOP_DETECTED = 3;
 
-        /**
-         * Indicates the reason why the exception is thrown. It will have
-         * one of the above 4 values.
-         */
+        /// <summary>
+        /// Indicates the reason why the exception is thrown. It will have
+        /// one of the above 4 values.
+        /// </summary>
         internal int errorCode;
 
-        /**
-         * Replaces unprintable characters by their escaped (or unicode escaped)
-         * equivalents in the given string
-         */
+        /// <summary>
+        /// Replaces unprintable characters by their escaped (or unicode escaped)
+        /// equivalents in the given string
+        /// </summary>
         protected static string AddEscapes(string str)
         {
             StringBuilder retval = new StringBuilder();
@@ -111,18 +109,17 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Parser
             return retval.ToString();
         }
 
-        /**
-         * Returns a detailed message for the Error when it is thrown by the
-         * token manager to indicate a lexical error.
-         * Parameters :
-         *    EOFSeen     : indicates if EOF caused the lexical error
-         *    curLexState : lexical state in which this error occurred
-         *    errorLine   : line number when the error occurred
-         *    errorColumn : column number when the error occurred
-         *    errorAfter  : prefix that was seen before this error occurred
-         *    curchar     : the offending character
-         * Note: You can customize the lexical error message by modifying this method.
-         */
+        /// <summary>
+        /// Returns a detailed message for the Error when it is thrown by the
+        /// token manager to indicate a lexical error.
+        /// </summary>
+        /// <param name="EOFSeen">indicates if EOF caused the lexical error</param>
+        /// <param name="lexState">lexical state in which this error occurred</param>
+        /// <param name="errorLine">line number when the error occurred</param>
+        /// <param name="errorColumn">column number when the error occurred</param>
+        /// <param name="errorAfter">prefix that was seen before this error occurred</param>
+        /// <param name="curChar">the offending character</param>
+        /// <remarks>Note: You can customize the lexical error message by modifying this method.</remarks>
         protected static string LexicalError(bool EOFSeen, int lexState, int errorLine, int errorColumn, string errorAfter, char curChar)
         {
             return ("Lexical error at line " +
@@ -132,37 +129,42 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Parser
                   "after : \"" + AddEscapes(errorAfter) + "\"");
         }
 
-        /**
-         * You can also modify the body of this method to customize your error messages.
-         * For example, cases like LOOP_DETECTED and INVALID_LEXICAL_STATE are not
-         * of end-users concern, so you can return something like :
-         *
-         *     "Internal Error : Please file a bug report .... "
-         *
-         * from this method for such cases in the release version of your parser.
-         */
+        /// <summary>
+        /// You can also modify the body of this method to customize your error messages.
+        /// For example, cases like LOOP_DETECTED and INVALID_LEXICAL_STATE are not
+        /// of end-users concern, so you can return something like :
+        /// 
+        ///     "Internal Error : Please file a bug report .... "
+        ///     
+        /// from this method for such cases in the release version of your parser.
+        /// </summary>
         public override string Message
         {
             get { return base.Message; }
         }
 
-        /*
-         * Constructors of various flavors follow.
-         */
+        // Constructors of various flavors follow.
 
-        /** No arg constructor. */
+        /// <summary>No arg constructor.</summary>
         public TokenMgrError()
         {
         }
 
-        /** Constructor with message and reason. */
+        /// <summary>Constructor with message and reason.</summary>
         public TokenMgrError(string message, int reason)
             : base(message)
         {
             errorCode = reason;
         }
 
-        /** Full Constructor. */
+        /// <summary>Full Constructor.</summary>
+        /// <param name="EOFSeen">indicates if EOF caused the lexical error</param>
+        /// <param name="lexState">lexical state in which this error occurred</param>
+        /// <param name="errorLine">line number when the error occurred</param>
+        /// <param name="errorColumn">column number when the error occurred</param>
+        /// <param name="errorAfter">prefix that was seen before this error occurred</param>
+        /// <param name="curChar">the offending character</param>
+        /// <param name="reason"></param>
         public TokenMgrError(bool EOFSeen, int lexState, int errorLine, int errorColumn, string errorAfter, char curChar, int reason)
             : this(LexicalError(EOFSeen, lexState, errorLine, errorColumn, errorAfter, curChar), reason)
         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/AllowLeadingWildcardProcessor.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/AllowLeadingWildcardProcessor.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/AllowLeadingWildcardProcessor.cs
index d117bca..23d6264 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/AllowLeadingWildcardProcessor.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/AllowLeadingWildcardProcessor.cs
@@ -30,12 +30,12 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
 
     /// <summary>
     /// This processor verifies if
-    /// {@link ConfigurationKeys#ALLOW_LEADING_WILDCARD} is defined in the
-    /// {@link QueryConfigHandler}. If it is and leading wildcard is not allowed, it
-    /// looks for every {@link WildcardQueryNode} contained in the query node tree
+    /// <see cref="ConfigurationKeys.ALLOW_LEADING_WILDCARD"/> is defined in the
+    /// <see cref="QueryConfigHandler"/>. If it is and leading wildcard is not allowed, it
+    /// looks for every <see cref="WildcardQueryNode"/> contained in the query node tree
     /// and throws an exception if any of them has a leading wildcard ('*' or '?').
     /// </summary>
-    /// <seealso cref="ConfigurationKeys#ALLOW_LEADING_WILDCARD"/>
+    /// <seealso cref="ConfigurationKeys.ALLOW_LEADING_WILDCARD"/>
     public class AllowLeadingWildcardProcessor : QueryNodeProcessorImpl
     {
         public AllowLeadingWildcardProcessor()

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/AnalyzerQueryNodeProcessor.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/AnalyzerQueryNodeProcessor.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/AnalyzerQueryNodeProcessor.cs
index 5f8f414..fb6001c 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/AnalyzerQueryNodeProcessor.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/AnalyzerQueryNodeProcessor.cs
@@ -32,24 +32,24 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
      */
 
     /// <summary>
-    /// This processor verifies if {@link ConfigurationKeys#ANALYZER}
-    /// is defined in the {@link QueryConfigHandler}. If it is and the analyzer is
-    /// not <code>null</code>, it looks for every {@link FieldQueryNode} that is not
-    /// {@link WildcardQueryNode}, {@link FuzzyQueryNode} or
-    /// {@link RangeQueryNode} contained in the query node tree, then it applies
-    /// the analyzer to that {@link FieldQueryNode} object.
+    /// This processor verifies if <see cref="ConfigurationKeys.ANALYZER"/>
+    /// is defined in the <see cref="Core.Config.QueryConfigHandler"/>. If it is and the analyzer is
+    /// not <c>null</c>, it looks for every <see cref="FieldQueryNode"/> that is not
+    /// <see cref="WildcardQueryNode"/>, <see cref="FuzzyQueryNode"/> or
+    /// <see cref="IRangeQueryNode"/> contained in the query node tree, then it applies
+    /// the analyzer to that <see cref="FieldQueryNode"/> object.
     /// <para/>
     /// If the analyzer return only one term, the returned term is set to the
-    /// {@link FieldQueryNode} and it's returned.
+    /// <see cref="FieldQueryNode"/> and it's returned.
     /// <para/>
-    /// If the analyzer return more than one term, a {@link TokenizedPhraseQueryNode}
-    /// or {@link MultiPhraseQueryNode} is created, whether there is one or more
+    /// If the analyzer return more than one term, a <see cref="TokenizedPhraseQueryNode"/>
+    /// or <see cref="MultiPhraseQueryNode"/> is created, whether there is one or more
     /// terms at the same position, and it's returned.
     /// <para/>
-    /// If no term is returned by the analyzer a {@link NoTokenFoundQueryNode} object
+    /// If no term is returned by the analyzer a <see cref="NoTokenFoundQueryNode"/> object
     /// is returned.
     /// </summary>
-    /// <seealso cref="ConfigurationKeys#ANALYZER"/>
+    /// <seealso cref="ConfigurationKeys.ANALYZER"/>
     /// <seealso cref="Analyzer"/>
     /// <seealso cref="TokenStream"/>
     public class AnalyzerQueryNodeProcessor : QueryNodeProcessorImpl

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/BooleanQuery2ModifierNodeProcessor.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/BooleanQuery2ModifierNodeProcessor.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/BooleanQuery2ModifierNodeProcessor.cs
index 500e629..08b40d2 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/BooleanQuery2ModifierNodeProcessor.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/BooleanQuery2ModifierNodeProcessor.cs
@@ -27,26 +27,26 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
      */
 
     /// <summary>
-    /// This processor is used to apply the correct {@link ModifierQueryNode} to
-    /// {@link BooleanQueryNode}s children. This is a variant of
-    /// {@link BooleanModifiersQueryNodeProcessor} which ignores precedence.
+    /// This processor is used to apply the correct <see cref="ModifierQueryNode"/> to
+    /// <see cref="BooleanQueryNode"/>s children. This is a variant of
+    /// <see cref="Precedence.Processors.BooleanModifiersQueryNodeProcessor"/> which ignores precedence.
     /// <para/>
-    /// The {@link StandardSyntaxParser} knows the rules of precedence, but lucene
+    /// The <see cref="Parser.StandardSyntaxParser"/> knows the rules of precedence, but lucene
     /// does not. e.g. <code>(A AND B OR C AND D)</code> ist treated like
     /// <code>(+A +B +C +D)</code>.
     /// <para/>
     /// This processor walks through the query node tree looking for
-    /// {@link BooleanQueryNode}s. If an {@link AndQueryNode} is found, every child,
-    /// which is not a {@link ModifierQueryNode} or the {@link ModifierQueryNode} is
-    /// {@link Modifier#MOD_NONE}, becomes a {@link Modifier#MOD_REQ}. For default
-    /// {@link BooleanQueryNode}, it checks the default operator is
-    /// {@link Operator#AND}, if it is, the same operation when an
-    /// {@link AndQueryNode} is found is applied to it. Each {@link BooleanQueryNode}
-    /// which direct parent is also a {@link BooleanQueryNode} is removed (to ignore
+    /// <see cref="BooleanQueryNode"/>s. If an <see cref="AndQueryNode"/> is found, every child,
+    /// which is not a <see cref="ModifierQueryNode"/> or the <see cref="ModifierQueryNode"/> is
+    /// <see cref="Modifier.MOD_NONE"/>, becomes a <see cref="Modifier.MOD_REQ"/>. For default
+    /// <see cref="BooleanQueryNode"/>, it checks the default operator is
+    /// <see cref="Operator.AND"/>, if it is, the same operation when an
+    /// <see cref="AndQueryNode"/> is found is applied to it. Each <see cref="BooleanQueryNode"/>
+    /// which direct parent is also a <see cref="BooleanQueryNode"/> is removed (to ignore
     /// the rules of precedence).
     /// </summary>
-    /// <seealso cref="ConfigurationKeys#DEFAULT_OPERATOR"/>
-    /// <seealso cref="BooleanModifiersQueryNodeProcessor"/>
+    /// <seealso cref="ConfigurationKeys.DEFAULT_OPERATOR"/>
+    /// <seealso cref="Precedence.Processors.BooleanModifiersQueryNodeProcessor"/>
     public class BooleanQuery2ModifierNodeProcessor : IQueryNodeProcessor
     {
         internal readonly static string TAG_REMOVE = "remove";

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/BooleanSingleChildOptimizationQueryNodeProcessor.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/BooleanSingleChildOptimizationQueryNodeProcessor.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/BooleanSingleChildOptimizationQueryNodeProcessor.cs
index 2d10381..4e0e807 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/BooleanSingleChildOptimizationQueryNodeProcessor.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/BooleanSingleChildOptimizationQueryNodeProcessor.cs
@@ -23,10 +23,10 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
      */
 
     /// <summary>
-    /// This processor removes every {@link BooleanQueryNode} that contains only one
-    /// child and returns this child. If this child is {@link ModifierQueryNode} that
+    /// This processor removes every <see cref="BooleanQueryNode"/> that contains only one
+    /// child and returns this child. If this child is <see cref="ModifierQueryNode"/> that
     /// was defined by the user. A modifier is not defined by the user when it's a
-    /// {@link BooleanModifierNode}
+    /// <see cref="BooleanModifierNode"/>
     /// </summary>
     /// <seealso cref="ModifierQueryNode"/>
     public class BooleanSingleChildOptimizationQueryNodeProcessor : QueryNodeProcessorImpl

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/BoostQueryNodeProcessor.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/BoostQueryNodeProcessor.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/BoostQueryNodeProcessor.cs
index 43b2582..938e2a7 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/BoostQueryNodeProcessor.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/BoostQueryNodeProcessor.cs
@@ -26,10 +26,10 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
 
     /// <summary>
     /// This processor iterates the query node tree looking for every
-    /// {@link FieldableNode} that has {@link ConfigurationKeys#BOOST} in its
-    /// config. If there is, the boost is applied to that {@link FieldableNode}.
+    /// <see cref="IFieldableNode"/> that has <see cref="ConfigurationKeys.BOOST"/> in its
+    /// config. If there is, the boost is applied to that <see cref="IFieldableNode"/>.
     /// </summary>
-    /// <seealso cref="ConfigurationKeys#BOOST"/>
+    /// <seealso cref="ConfigurationKeys.BOOST"/>
     /// <seealso cref="QueryConfigHandler"/>
     /// <seealso cref="IFieldableNode"/>
     public class BoostQueryNodeProcessor : QueryNodeProcessorImpl

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/DefaultPhraseSlopQueryNodeProcessor.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/DefaultPhraseSlopQueryNodeProcessor.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/DefaultPhraseSlopQueryNodeProcessor.cs
index 3694d73..7460536 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/DefaultPhraseSlopQueryNodeProcessor.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/DefaultPhraseSlopQueryNodeProcessor.cs
@@ -25,15 +25,15 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
      */
 
     /// <summary>
-    /// This processor verifies if {@link ConfigurationKeys#PHRASE_SLOP}
-    /// is defined in the {@link QueryConfigHandler}. If it is, it looks for every
-    /// {@link TokenizedPhraseQueryNode} and {@link MultiPhraseQueryNode} that does
-    /// not have any {@link SlopQueryNode} applied to it and creates an
-    /// {@link SlopQueryNode} and apply to it. The new {@link SlopQueryNode} has the
+    /// This processor verifies if <see cref="ConfigurationKeys.PHRASE_SLOP"/>
+    /// is defined in the <see cref="QueryConfigHandler"/>. If it is, it looks for every
+    /// <see cref="TokenizedPhraseQueryNode"/> and <see cref="MultiPhraseQueryNode"/> that does
+    /// not have any <see cref="SlopQueryNode"/> applied to it and creates an
+    /// <see cref="SlopQueryNode"/> and apply to it. The new <see cref="SlopQueryNode"/> has the
     /// same slop value defined in the configuration.
     /// </summary>
     /// <seealso cref="SlopQueryNode"/>
-    /// <seealso cref="ConfigurationKeys#PHRASE_SLOP"/>
+    /// <seealso cref="ConfigurationKeys.PHRASE_SLOP"/>
     public class DefaultPhraseSlopQueryNodeProcessor : QueryNodeProcessorImpl
     {
         private bool processChildren = true;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/FuzzyQueryNodeProcessor.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/FuzzyQueryNodeProcessor.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/FuzzyQueryNodeProcessor.cs
index 5096f09..a7a224e 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/FuzzyQueryNodeProcessor.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/FuzzyQueryNodeProcessor.cs
@@ -26,14 +26,14 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
 
     /// <summary>
     /// This processor iterates the query node tree looking for every
-    /// {@link FuzzyQueryNode}, when this kind of node is found, it checks on the
+    /// <see cref="FuzzyQueryNode"/>, when this kind of node is found, it checks on the
     /// query configuration for
-    /// {@link ConfigurationKeys#FUZZY_CONFIG}, gets the
+    /// <see cref="ConfigurationKeys.FUZZY_CONFIG"/>, gets the
     /// fuzzy prefix length and default similarity from it and set to the fuzzy node.
-    /// For more information about fuzzy prefix length check: {@link FuzzyQuery}.
+    /// For more information about fuzzy prefix length check: <see cref="Search.FuzzyQuery"/>.
     /// </summary>
-    /// <seealso cref="ConfigurationKeys#FUZZY_CONFIG"/>
-    /// <seealso cref="FuzzyQuery"/>
+    /// <seealso cref="ConfigurationKeys.FUZZY_CONFIG"/>
+    /// <seealso cref="Search.FuzzyQuery"/>
     /// <seealso cref="FuzzyQueryNode"/>
     public class FuzzyQueryNodeProcessor : QueryNodeProcessorImpl
     {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/GroupQueryNodeProcessor.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/GroupQueryNodeProcessor.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/GroupQueryNodeProcessor.cs
index aa43ec1..b80fd1b 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/GroupQueryNodeProcessor.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/GroupQueryNodeProcessor.cs
@@ -28,13 +28,13 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
      */
 
     /// <summary>
-    /// The {@link SyntaxParser}
+    /// The <see cref="Core.Parser.ISyntaxParser"/>
     /// generates query node trees that consider the boolean operator precedence, but
     /// Lucene current syntax does not support boolean precedence, so this processor
     /// remove all the precedence and apply the equivalent modifier according to the
     /// boolean operation defined on an specific query node.
     /// <para/>
-    /// If there is a {@link GroupQueryNode} in the query node tree, the query node
+    /// If there is a <see cref="GroupQueryNode"/> in the query node tree, the query node
     /// tree is not merged with the one above it.
     /// <para/>
     /// Example: TODO: describe a good example to show how this processor works
@@ -103,8 +103,6 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
             }
         }
 
-        /**
-         */
         private IQueryNode ApplyModifier(IQueryNode node, IQueryNode parent)
         {
             if (this.usingAnd)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/LowercaseExpandedTermsQueryNodeProcessor.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/LowercaseExpandedTermsQueryNodeProcessor.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/LowercaseExpandedTermsQueryNodeProcessor.cs
index f145498..484d462 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/LowercaseExpandedTermsQueryNodeProcessor.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/LowercaseExpandedTermsQueryNodeProcessor.cs
@@ -28,13 +28,13 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
 
     /// <summary>
     /// This processor verifies if 
-    /// {@link ConfigurationKeys#LOWERCASE_EXPANDED_TERMS} is defined in the
-    /// {@link QueryConfigHandler}. If it is and the expanded terms should be
-    /// lower-cased, it looks for every {@link WildcardQueryNode},
-    /// {@link FuzzyQueryNode} and children of a {@link RangeQueryNode} and lower-case its
+    /// <see cref="ConfigurationKeys.LOWERCASE_EXPANDED_TERMS"/> is defined in the
+    /// <see cref="Core.Config.QueryConfigHandler"/>. If it is and the expanded terms should be
+    /// lower-cased, it looks for every <see cref="WildcardQueryNode"/>,
+    /// <see cref="FuzzyQueryNode"/> and children of a <see cref="IRangeQueryNode"/> and lower-case its
     /// term.
     /// </summary>
-    /// <seealso cref="ConfigurationKeys#LOWERCASE_EXPANDED_TERMS"/>.
+    /// <seealso cref="ConfigurationKeys.LOWERCASE_EXPANDED_TERMS"/>.
     public class LowercaseExpandedTermsQueryNodeProcessor : QueryNodeProcessorImpl
     {
         public LowercaseExpandedTermsQueryNodeProcessor()

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/MatchAllDocsQueryNodeProcessor.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/MatchAllDocsQueryNodeProcessor.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/MatchAllDocsQueryNodeProcessor.cs
index 8c5c61c..adccff8 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/MatchAllDocsQueryNodeProcessor.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/MatchAllDocsQueryNodeProcessor.cs
@@ -22,11 +22,11 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
      */
 
     /// <summary>
-    /// This processor converts every {@link WildcardQueryNode} that is "*:*" to
-    /// {@link MatchAllDocsQueryNode}.
+    /// This processor converts every <see cref="Nodes.WildcardQueryNode"/> that is "*:*" to
+    /// <see cref="MatchAllDocsQueryNode"/>.
     /// </summary>
     /// <seealso cref="MatchAllDocsQueryNode"/>
-    /// <seealso cref="MatchAllDocsQuery"/>
+    /// <seealso cref="Search.MatchAllDocsQuery"/>
     public class MatchAllDocsQueryNodeProcessor : QueryNodeProcessorImpl
     {
         public MatchAllDocsQueryNodeProcessor()

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/MultiFieldQueryNodeProcessor.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/MultiFieldQueryNodeProcessor.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/MultiFieldQueryNodeProcessor.cs
index 7694d01..35bac44 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/MultiFieldQueryNodeProcessor.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/MultiFieldQueryNodeProcessor.cs
@@ -27,15 +27,15 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
     /// This processor is used to expand terms so the query looks for the same term
     /// in different fields. It also boosts a query based on its field.
     /// <para/>
-    /// This processor looks for every {@link FieldableNode} contained in the query
-    /// node tree. If a {@link FieldableNode} is found, it checks if there is a
-    /// {@link ConfigurationKeys#MULTI_FIELDS} defined in the {@link QueryConfigHandler}. If
-    /// there is, the {@link FieldableNode} is cloned N times and the clones are
-    /// added to a {@link BooleanQueryNode} together with the original node. N is
+    /// This processor looks for every <see cref="IFieldableNode"/> contained in the query
+    /// node tree. If a <see cref="IFieldableNode"/> is found, it checks if there is a
+    /// <see cref="ConfigurationKeys.MULTI_FIELDS"/> defined in the <see cref="Core.Config.QueryConfigHandler"/>. If
+    /// there is, the <see cref="IFieldableNode"/> is cloned N times and the clones are
+    /// added to a <see cref="BooleanQueryNode"/> together with the original node. N is
     /// defined by the number of fields that it will be expanded to. The
-    /// {@link BooleanQueryNode} is returned.
+    /// <see cref="BooleanQueryNode"/> is returned.
     /// </summary>
-    /// <seealso cref="ConfigurationKeys#MULTI_FIELDS"/>
+    /// <seealso cref="ConfigurationKeys.MULTI_FIELDS"/>
     public class MultiFieldQueryNodeProcessor : QueryNodeProcessorImpl
     {
         private bool processChildren = true;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/MultiTermRewriteMethodProcessor.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/MultiTermRewriteMethodProcessor.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/MultiTermRewriteMethodProcessor.cs
index f5e4d3e..08758e4 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/MultiTermRewriteMethodProcessor.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/MultiTermRewriteMethodProcessor.cs
@@ -27,8 +27,8 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
 
     /// <summary>
     /// This processor instates the default
-    /// {@link org.apache.lucene.search.MultiTermQuery.RewriteMethod},
-    /// {@link MultiTermQuery#CONSTANT_SCORE_AUTO_REWRITE_DEFAULT}, for multi-term
+    /// <see cref="MultiTermQuery.RewriteMethod"/>,
+    /// <see cref="MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT"/>, for multi-term
     /// query nodes.
     /// </summary>
     public class MultiTermRewriteMethodProcessor : QueryNodeProcessorImpl

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/NumericQueryNodeProcessor.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/NumericQueryNodeProcessor.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/NumericQueryNodeProcessor.cs
index b518b5d..5b008d8 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/NumericQueryNodeProcessor.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/NumericQueryNodeProcessor.cs
@@ -31,29 +31,29 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
      */
 
     /// <summary>
-    /// This processor is used to convert {@link FieldQueryNode}s to
-    /// {@link NumericRangeQueryNode}s. It looks for
-    /// {@link ConfigurationKeys#NUMERIC_CONFIG} set in the {@link FieldConfig} of
-    /// every {@link FieldQueryNode} found. If
-    /// {@link ConfigurationKeys#NUMERIC_CONFIG} is found, it considers that
-    /// {@link FieldQueryNode} to be a numeric query and convert it to
-    /// {@link NumericRangeQueryNode} with upper and lower inclusive and lower and
-    /// upper equals to the value represented by the {@link FieldQueryNode} converted
-    /// to {@link Number}. It means that <b>field:1</b> is converted to <b>field:[1
+    /// This processor is used to convert <see cref="FieldQueryNode"/>s to
+    /// <see cref="NumericRangeQueryNode"/>s. It looks for
+    /// <see cref="ConfigurationKeys.NUMERIC_CONFIG"/> set in the <see cref="FieldConfig"/> of
+    /// every <see cref="FieldQueryNode"/> found. If
+    /// <see cref="ConfigurationKeys.NUMERIC_CONFIG"/> is found, it considers that
+    /// <see cref="FieldQueryNode"/> to be a numeric query and convert it to
+    /// <see cref="NumericRangeQueryNode"/> with upper and lower inclusive and lower and
+    /// upper equals to the value represented by the <see cref="FieldQueryNode"/> converted
+    /// to <see cref="object"/> representing a .NET numeric type. It means that <b>field:1</b> is converted to <b>field:[1
     /// TO 1]</b>.
     /// <para/>
-    /// Note that {@link FieldQueryNode}s children of a
-    /// {@link RangeQueryNode} are ignored.
+    /// Note that <see cref="FieldQueryNode"/>s children of a
+    /// <see cref="RangeQueryNode"/> are ignored.
     /// </summary>
-    /// <seealso cref="ConfigurationKeys#NUMERIC_CONFIG"/>
+    /// <seealso cref="ConfigurationKeys.NUMERIC_CONFIG"/>
     /// <seealso cref="FieldQueryNode"/>
     /// <seealso cref="NumericConfig"/>
     /// <seealso cref="NumericQueryNode"/>
     public class NumericQueryNodeProcessor : QueryNodeProcessorImpl
     {
-        /**
-   * Constructs a {@link NumericQueryNodeProcessor} object.
-   */
+        /// <summary>
+        /// Constructs a <see cref="NumericQueryNodeProcessor"/> object.
+        /// </summary>
         public NumericQueryNodeProcessor()
         {
             // empty constructor

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/NumericRangeQueryNodeProcessor.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/NumericRangeQueryNodeProcessor.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/NumericRangeQueryNodeProcessor.cs
index 9388144..8b90df6 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/NumericRangeQueryNodeProcessor.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/NumericRangeQueryNodeProcessor.cs
@@ -32,23 +32,23 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
      */
 
     /// <summary>
-    /// This processor is used to convert {@link TermRangeQueryNode}s to
-    /// {@link NumericRangeQueryNode}s. It looks for
-    /// {@link ConfigurationKeys#NUMERIC_CONFIG} set in the {@link FieldConfig} of
-    /// every {@link TermRangeQueryNode} found. If
-    /// {@link ConfigurationKeys#NUMERIC_CONFIG} is found, it considers that
-    /// {@link TermRangeQueryNode} to be a numeric range query and convert it to
-    /// {@link NumericRangeQueryNode}.
+    /// This processor is used to convert <see cref="TermRangeQueryNode"/>s to
+    /// <see cref="NumericRangeQueryNode"/>s. It looks for
+    /// <see cref="ConfigurationKeys.NUMERIC_CONFIG"/> set in the <see cref="FieldConfig"/> of
+    /// every <see cref="TermRangeQueryNode"/> found. If
+    /// <see cref="ConfigurationKeys.NUMERIC_CONFIG"/> is found, it considers that
+    /// <see cref="TermRangeQueryNode"/> to be a numeric range query and convert it to
+    /// <see cref="NumericRangeQueryNode"/>.
     /// </summary>
-    /// <seealso cref="ConfigurationKeys#NUMERIC_CONFIG"/>
+    /// <seealso cref="ConfigurationKeys.NUMERIC_CONFIG"/>
     /// <seealso cref="TermRangeQueryNode"/>
     /// <seealso cref="NumericConfig"/>
     /// <seealso cref="NumericRangeQueryNode"/>
     public class NumericRangeQueryNodeProcessor : QueryNodeProcessorImpl
     {
-        /**
-   * Constructs an empty {@link NumericRangeQueryNode} object.
-   */
+        /// <summary>
+        /// Constructs an empty <see cref="NumericRangeQueryNode"/> object.
+        /// </summary>
         public NumericRangeQueryNodeProcessor()
         {
             // empty constructor

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/OpenRangeQueryNodeProcessor.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/OpenRangeQueryNodeProcessor.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/OpenRangeQueryNodeProcessor.cs
index 4ee5d58..5cf8111 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/OpenRangeQueryNodeProcessor.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/OpenRangeQueryNodeProcessor.cs
@@ -25,7 +25,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
      */
 
     /// <summary>
-    /// Processes {@link TermRangeQuery}s with open ranges.
+    /// Processes <see cref="Search.TermRangeQuery"/>s with open ranges.
     /// </summary>
     public class OpenRangeQueryNodeProcessor : QueryNodeProcessorImpl
     {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/PhraseSlopQueryNodeProcessor.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/PhraseSlopQueryNodeProcessor.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/PhraseSlopQueryNodeProcessor.cs
index 728abeb..f6880e5 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/PhraseSlopQueryNodeProcessor.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/PhraseSlopQueryNodeProcessor.cs
@@ -23,9 +23,9 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
      */
 
     /// <summary>
-    /// This processor removes invalid {@link SlopQueryNode} objects in the query
-    /// node tree. A {@link SlopQueryNode} is invalid if its child is neither a
-    /// {@link TokenizedPhraseQueryNode} nor a {@link MultiPhraseQueryNode}.
+    /// This processor removes invalid <see cref="SlopQueryNode"/> objects in the query
+    /// node tree. A <see cref="SlopQueryNode"/> is invalid if its child is neither a
+    /// <see cref="TokenizedPhraseQueryNode"/> nor a <see cref="MultiPhraseQueryNode"/>.
     /// </summary>
     /// <seealso cref="SlopQueryNode"/>
     public class PhraseSlopQueryNodeProcessor : QueryNodeProcessorImpl

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/RemoveEmptyNonLeafQueryNodeProcessor.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/RemoveEmptyNonLeafQueryNodeProcessor.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/RemoveEmptyNonLeafQueryNodeProcessor.cs
index fdb87bb..c7452a9 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/RemoveEmptyNonLeafQueryNodeProcessor.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/RemoveEmptyNonLeafQueryNodeProcessor.cs
@@ -23,15 +23,15 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
      */
 
     /// <summary>
-    /// This processor removes every {@link QueryNode} that is not a leaf and has not
+    /// This processor removes every <see cref="IQueryNode"/> that is not a leaf and has not
     /// children. If after processing the entire tree the root node is not a leaf and
-    /// has no children, a {@link MatchNoDocsQueryNode} object is returned.
+    /// has no children, a <see cref="MatchNoDocsQueryNode"/> object is returned.
     /// <para/>
     /// This processor is used at the end of a pipeline to avoid invalid query node
-    /// tree structures like a {@link GroupQueryNode} or {@link ModifierQueryNode}
+    /// tree structures like a <see cref="GroupQueryNode"/> or <see cref="ModifierQueryNode"/>
     /// with no children.
     /// </summary>
-    /// <seealso cref="QueryNode"/>
+    /// <seealso cref="IQueryNode"/>
     /// <seealso cref="MatchNoDocsQueryNode"/>
     public class RemoveEmptyNonLeafQueryNodeProcessor : QueryNodeProcessorImpl
     {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/StandardQueryNodeProcessorPipeline.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/StandardQueryNodeProcessorPipeline.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/StandardQueryNodeProcessorPipeline.cs
index e0e4907..64c7a00 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/StandardQueryNodeProcessorPipeline.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/StandardQueryNodeProcessorPipeline.cs
@@ -22,19 +22,19 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
 
     /// <summary>
     /// This pipeline has all the processors needed to process a query node tree,
-    /// generated by {@link StandardSyntaxParser}, already assembled.
+    /// generated by <see cref="Parser.StandardSyntaxParser"/>, already assembled.
     /// <para/>
     /// The order they are assembled affects the results.
     /// <para/>
     /// This processor pipeline was designed to work with
-    /// {@link StandardQueryConfigHandler}.
+    /// <see cref="Config.StandardQueryConfigHandler"/>.
     /// <para/>
-    /// The result query node tree can be used to build a {@link Query} object using
-    /// {@link StandardQueryTreeBuilder}.
+    /// The result query node tree can be used to build a <see cref="Query"/> object using
+    /// <see cref="Builders.StandardQueryTreeBuilder"/>.
     /// </summary>
-    /// <seealso cref="StandardQueryTreeBuilder"/>
-    /// <seealso cref="StandardQueryConfigHandler"/>
-    /// <seealso cref="StandardSyntaxParser"/>
+    /// <seealso cref="Builders.StandardQueryTreeBuilder"/>
+    /// <seealso cref="Config.StandardQueryConfigHandler"/>
+    /// <seealso cref="Parser.StandardSyntaxParser"/>
     public class StandardQueryNodeProcessorPipeline : QueryNodeProcessorPipeline
     {
         public StandardQueryNodeProcessorPipeline(QueryConfigHandler queryConfig)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/TermRangeQueryNodeProcessor.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/TermRangeQueryNodeProcessor.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/TermRangeQueryNodeProcessor.cs
index 3e8752f..23cb18d 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/TermRangeQueryNodeProcessor.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/TermRangeQueryNodeProcessor.cs
@@ -29,22 +29,22 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
      */
 
     /// <summary>
-    /// This processors process {@link TermRangeQueryNode}s. It reads the lower and
-    /// upper bounds value from the {@link TermRangeQueryNode} object and try
-    /// to parse their values using a {@link DateFormat}. If the values cannot be
-    /// parsed to a date value, it will only create the {@link TermRangeQueryNode}
+    /// This processors process <see cref="TermRangeQueryNode"/>s. It reads the lower and
+    /// upper bounds value from the <see cref="TermRangeQueryNode"/> object and try
+    /// to parse their values using a <paramref name="dateFormat"/>. If the values cannot be
+    /// parsed to a date value, it will only create the <see cref="TermRangeQueryNode"/>
     /// using the non-parsed values.
     /// <para/>
-    /// If a {@link ConfigurationKeys#LOCALE} is defined in the
-    /// {@link QueryConfigHandler} it will be used to parse the date, otherwise
-    /// {@link Locale#getDefault()} will be used.
+    /// If a <see cref="ConfigurationKeys.LOCALE"/> is defined in the
+    /// <see cref="QueryConfigHandler"/> it will be used to parse the date, otherwise
+    /// <see cref="CultureInfo.CurrentCulture"/> will be used.
     /// <para/>
-    /// If a {@link ConfigurationKeys#DATE_RESOLUTION} is defined and the
-    /// {@link Resolution} is not <code>null</code> it will also be used to parse the
+    /// If a <see cref="ConfigurationKeys.DATE_RESOLUTION"/> is defined and the
+    /// <see cref="DateTools.Resolution"/> is not <c>null</c> it will also be used to parse the
     /// date value.
     /// </summary>
-    /// <seealso cref="ConfigurationKeys#DATE_RESOLUTION"/>
-    /// <seealso cref="ConfigurationKeys#LOCALE"/>
+    /// <seealso cref="ConfigurationKeys.DATE_RESOLUTION"/>
+    /// <seealso cref="ConfigurationKeys.LOCALE"/>
     /// <seealso cref="TermRangeQueryNode"/>
     public class TermRangeQueryNodeProcessor : QueryNodeProcessorImpl
     {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/WildcardQueryNodeProcessor.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/WildcardQueryNodeProcessor.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/WildcardQueryNodeProcessor.cs
index 3faecc6..df05e23 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/WildcardQueryNodeProcessor.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/Processors/WildcardQueryNodeProcessor.cs
@@ -25,13 +25,13 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard.Processors
      */
 
     /// <summary>
-    /// The {@link StandardSyntaxParser} creates {@link PrefixWildcardQueryNode} nodes which
+    /// The <see cref="Parser.StandardSyntaxParser"/> creates <see cref="PrefixWildcardQueryNode"/> nodes which
     /// have values containing the prefixed wildcard. However, Lucene
-    /// {@link PrefixQuery} cannot contain the prefixed wildcard. So, this processor
+    /// <see cref="Search.PrefixQuery"/> cannot contain the prefixed wildcard. So, this processor
     /// basically removed the prefixed wildcard from the
-    /// {@link PrefixWildcardQueryNode} value.
+    /// <see cref="PrefixWildcardQueryNode"/> value.
     /// </summary>
-    /// <seealso cref="PrefixQuery"/>
+    /// <seealso cref="Search.PrefixQuery"/>
     /// <seealso cref="PrefixWildcardQueryNode"/>
     public class WildcardQueryNodeProcessor : QueryNodeProcessorImpl
     {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/QueryParserUtil.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/QueryParserUtil.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/QueryParserUtil.cs
index 1d9ef50..1e720e6 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/QueryParserUtil.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/QueryParserUtil.cs
@@ -24,31 +24,25 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard
 
     /// <summary>
     /// This class defines utility methods to (help) parse query strings into
-    /// {@link Query} objects.
+    /// <see cref="Query"/> objects.
     /// </summary>
     public sealed class QueryParserUtil
     {
-        /**
-   * Parses a query which searches on the fields specified.
-   * <p>
-   * If x fields are specified, this effectively constructs:
-   * 
-   * <pre>
-   * <code>
-   * (field1:query1) (field2:query2) (field3:query3)...(fieldx:queryx)
-   * </code>
-   * </pre>
-   * 
-   * @param queries
-   *          Queries strings to parse
-   * @param fields
-   *          Fields to search on
-   * @param analyzer
-   *          Analyzer to use
-   * @throws IllegalArgumentException
-   *           if the length of the queries array differs from the length of the
-   *           fields array
-   */
+        /// <summary>
+        /// Parses a query which searches on the fields specified.
+        /// <para/>
+        /// If x fields are specified, this effectively constructs:
+        /// <code>
+        /// (field1:query1) (field2:query2) (field3:query3)...(fieldx:queryx)
+        /// </code>
+        /// </summary>
+        /// <param name="queries">Queries strings to parse</param>
+        /// <param name="fields">Fields to search on</param>
+        /// <param name="analyzer">Analyzer to use</param>
+        /// <exception cref="ArgumentException">
+        /// if the length of the queries array differs from the length of the
+        /// fields array
+        /// </exception>
         public static Query Parse(string[] queries, string[] fields, Analyzer analyzer)
         {
             if (queries.Length != fields.Length)
@@ -71,42 +65,32 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard
             return bQuery;
         }
 
-        /**
-         * Parses a query, searching on the fields specified. Use this if you need to
-         * specify certain fields as required, and others as prohibited.
-         * <p>
-         * 
-         * Usage:
-         * <pre class="prettyprint">
-         * <code>
-         * String[] fields = {&quot;filename&quot;, &quot;contents&quot;, &quot;description&quot;};
-         * BooleanClause.Occur[] flags = {BooleanClause.Occur.SHOULD,
-         *                BooleanClause.Occur.MUST,
-         *                BooleanClause.Occur.MUST_NOT};
-         * MultiFieldQueryParser.parse(&quot;query&quot;, fields, flags, analyzer);
-         * </code>
-         * </pre>
-         *<p>
-         * The code above would construct a query:
-         * 
-         * <pre>
-         * <code>
-         * (filename:query) +(contents:query) -(description:query)
-         * </code>
-         * </pre>
-         * 
-         * @param query
-         *          Query string to parse
-         * @param fields
-         *          Fields to search on
-         * @param flags
-         *          Flags describing the fields
-         * @param analyzer
-         *          Analyzer to use
-         * @throws IllegalArgumentException
-         *           if the length of the fields array differs from the length of the
-         *           flags array
-         */
+        /// <summary>
+        /// Parses a query, searching on the fields specified. Use this if you need to
+        /// specify certain fields as required, and others as prohibited.
+        /// <para/>
+        /// Usage:
+        /// <code>
+        /// string[] fields = {&quot;filename&quot;, &quot;contents&quot;, &quot;description&quot;};
+        /// BooleanClause.Occur[] flags = {BooleanClause.Occur.SHOULD,
+        ///     BooleanClause.Occur.MUST,
+        ///     BooleanClause.Occur.MUST_NOT};
+        /// MultiFieldQueryParser.Parse(&quot;query&quot;, fields, flags, analyzer);
+        /// </code>
+        /// <para/>
+        /// The code above would construct a query:
+        /// <code>
+        /// (filename:query) +(contents:query) -(description:query)
+        /// </code>
+        /// </summary>
+        /// <param name="query">Query string to parse</param>
+        /// <param name="fields">Fields to search on</param>
+        /// <param name="flags">Flags describing the fields</param>
+        /// <param name="analyzer">Analyzer to use</param>
+        /// <exception cref="ArgumentException">
+        /// if the length of the fields array differs from the length of the
+        /// flags array
+        /// </exception>
         public static Query Parse(string query, string[] fields,
             BooleanClause.Occur[] flags, Analyzer analyzer)
         {
@@ -130,42 +114,32 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard
             return bQuery;
         }
 
-        /**
-         * Parses a query, searching on the fields specified. Use this if you need to
-         * specify certain fields as required, and others as prohibited.
-         * <p>
-         * 
-         * Usage:
-         * <pre class="prettyprint">
-         * <code>
-         * String[] query = {&quot;query1&quot;, &quot;query2&quot;, &quot;query3&quot;};
-         * String[] fields = {&quot;filename&quot;, &quot;contents&quot;, &quot;description&quot;};
-         * BooleanClause.Occur[] flags = {BooleanClause.Occur.SHOULD,
-         *                BooleanClause.Occur.MUST,
-         *                BooleanClause.Occur.MUST_NOT};
-         * MultiFieldQueryParser.parse(query, fields, flags, analyzer);
-         * </code>
-         * </pre>
-         *<p>
-         * The code above would construct a query:
-         * 
-         * <pre>
-         * <code>
-         * (filename:query1) +(contents:query2) -(description:query3)
-         * </code>
-         * </pre>
-         * 
-         * @param queries
-         *          Queries string to parse
-         * @param fields
-         *          Fields to search on
-         * @param flags
-         *          Flags describing the fields
-         * @param analyzer
-         *          Analyzer to use
-         * @throws IllegalArgumentException
-         *           if the length of the queries, fields, and flags array differ
-         */
+        /// <summary>
+        /// Parses a query, searching on the fields specified. Use this if you need to
+        /// specify certain fields as required, and others as prohibited.
+        /// <para/>
+        /// Usage:
+        /// <code>
+        /// string[] query = {&quot;query1&quot;, &quot;query2&quot;, &quot;query3&quot;};
+        /// string[] fields = {&quot;filename&quot;, &quot;contents&quot;, &quot;description&quot;};
+        /// BooleanClause.Occur[] flags = {BooleanClause.Occur.SHOULD,
+        ///     BooleanClause.Occur.MUST,
+        ///     BooleanClause.Occur.MUST_NOT};
+        /// MultiFieldQueryParser.Parse(query, fields, flags, analyzer);
+        /// </code>
+        /// <para/>
+        /// The code above would construct a query:
+        /// <code>
+        /// (filename:query1) +(contents:query2) -(description:query3)
+        /// </code>
+        /// </summary>
+        /// <param name="queries">Queries string to parse</param>
+        /// <param name="fields">Fields to search on</param>
+        /// <param name="flags">Flags describing the fields</param>
+        /// <param name="analyzer">Analyzer to use</param>
+        /// <exception cref="ArgumentException">
+        /// if the length of the queries, fields, and flags array differ
+        /// </exception>
         public static Query Parse(string[] queries, string[] fields,
             BooleanClause.Occur[] flags, Analyzer analyzer)
         {
@@ -190,10 +164,10 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard
             return bQuery;
         }
 
-        /**
-         * Returns a String where those characters that TextParser expects to be
-         * escaped are escaped by a preceding <code>\</code>.
-         */
+        /// <summary>
+        /// Returns a string where those characters that TextParser expects to be
+        /// escaped are escaped by a preceding <c>\</c>.
+        /// </summary>
         public static string Escape(string s)
         {
             StringBuilder sb = new StringBuilder();

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.QueryParser/Flexible/Standard/StandardQueryParser.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.QueryParser/Flexible/Standard/StandardQueryParser.cs b/src/Lucene.Net.QueryParser/Flexible/Standard/StandardQueryParser.cs
index 592bfc3..d06b05f 100644
--- a/src/Lucene.Net.QueryParser/Flexible/Standard/StandardQueryParser.cs
+++ b/src/Lucene.Net.QueryParser/Flexible/Standard/StandardQueryParser.cs
@@ -31,6 +31,75 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard
      * limitations under the License.
      */
 
+    /// <summary>
+    /// This class is a helper that enables users to easily use the Lucene query
+    /// parser.
+    /// <para/>
+    /// To construct a Query object from a query string, use the
+    /// <see cref="Parse(string, string)"/> method:
+    /// <code>
+    /// StandardQueryParser queryParserHelper = new StandardQueryParser();
+    /// Query query = queryParserHelper.Parse("a AND b", "defaultField");
+    /// </code>
+    /// <para/>
+    /// To change any configuration before parsing the query string do, for example:
+    /// <code>
+    /// // the query config handler returned by StandardQueryParser is a
+    /// // StandardQueryConfigHandler
+    /// queryParserHelper.QueryConfigHandler.Analyzer = new WhitespaceAnalyzer();
+    /// </code>
+    /// <para/>
+    /// The syntax for query strings is as follows (copied from the old QueryParser
+    /// javadoc):
+    /// <para/>
+    /// A Query is a series of clauses. A clause may be prefixed by:
+    /// <list type="bullet">
+    ///     <item>
+    ///     a plus (<c>+</c>) or a minus (<c>-</c>) sign, indicating that
+    ///     the clause is required or prohibited respectively; or
+    ///     </item>
+    ///     <item>
+    ///     a term followed by a colon, indicating the field to be searched. This
+    ///     enables one to construct queries which search multiple fields.
+    ///     </item>
+    /// </list>
+    /// 
+    /// A clause may be either:
+    /// <list type="bullet">
+    ///     <item>
+    ///     a term, indicating all the documents that contain this term; or
+    ///     </item>
+    ///     <item>
+    ///     a nested query, enclosed in parentheses. Note that this may be used with
+    ///     a <c>+</c>/<c>-</c> prefix to require any of a set of terms.
+    ///     </item>
+    /// </list>
+    /// 
+    /// Thus, in BNF, the query grammar is:
+    /// <code>
+    ///     Query  ::= ( Clause )*
+    ///     Clause ::= [&quot;+&quot;, &quot;-&quot;] [&lt;TERM&gt; &quot;:&quot;] ( &lt;TERM&gt; | &quot;(&quot; Query &quot;)&quot; )
+    /// </code>
+    /// 
+    /// <para>
+    /// Examples of appropriately formatted queries can be found in the query syntax documentation.
+    /// </para>
+    /// <para>
+    /// The text parser used by this helper is a <see cref="StandardSyntaxParser"/>.
+    /// </para>
+    /// <para>
+    /// The query node processor used by this helper is a
+    /// <see cref="StandardQueryNodeProcessorPipeline"/>.
+    /// </para>
+    /// <para>
+    /// The builder used by this helper is a <see cref="StandardQueryTreeBuilder"/>.
+    /// </para>
+    /// </summary>
+    /// <seealso cref="StandardQueryParser"/>
+    /// <seealso cref="StandardQueryConfigHandler"/>
+    /// <seealso cref="StandardSyntaxParser"/>
+    /// <seealso cref="StandardQueryNodeProcessorPipeline"/>
+    /// <seealso cref="StandardQueryTreeBuilder"/>
     public class StandardQueryParser : QueryParserHelper<Query>, ICommonQueryParserConfiguration
     {
         /// <summary>
@@ -46,7 +115,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard
 
         /// <summary>
         /// Constructs a <see cref="StandardQueryParser"/> object and sets an
-        /// <see cref="Analyzer"/> to it. The same as:
+        /// <see cref="Analysis.Analyzer"/> to it. The same as:
         /// <code>
         /// StandardQueryParser qp = new StandardQueryParser();
         /// qp.QueryConfigHandler.Analyzer = analyzer;
@@ -98,7 +167,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard
         /// Set to <c>true</c> to allow leading wildcard characters.
         /// <para/>
         /// When set, <c>*</c> or <c>?</c> are allowed as the first
-        /// character of a PrefixQuery and WildcardQuery. Note that this can produce
+        /// character of a <see cref="PrefixQuery"/> and <see cref="WildcardQuery"/>. Note that this can produce
         /// very slow queries on big indexes.
         /// <para/>
         /// Default: false.
@@ -120,7 +189,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard
         /// Set to <c>true</c> to allow leading wildcard characters.
         /// <para/>
         /// When set, <c>*</c> or <c>?</c> are allowed as the first
-        /// character of a PrefixQuery and WildcardQuery. Note that this can produce
+        /// character of a <see cref="PrefixQuery"/> and <see cref="WildcardQuery"/>. Note that this can produce
         /// very slow queries on big indexes.
         /// <para/>
         /// Default: false.
@@ -142,7 +211,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard
         /// Set to <c>true</c> to enable position increments in result query.
         /// <para/>
         /// When set, result phrase and multi-phrase queries will be aware of position
-        /// increments. Useful when e.g. a StopFilter increases the position increment
+        /// increments. Useful when e.g. a <see cref="Analysis.Core.StopFilter"/> increases the position increment
         /// of the token that follows an omitted token.
         /// <para/>
         /// Default: false.
@@ -299,7 +368,7 @@ namespace Lucene.Net.QueryParsers.Flexible.Standard
         }
 
         /// <summary>
-        /// Gets the default slop for phrases. If zero, then exact phrase matches are
+        /// Gets or Sets the default slop for phrases. If zero, then exact phrase matches are
         /// required. Default value is zero. NOTE: Setter is deprecated.
         /// </summary>
         public virtual int PhraseSlop

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/c6696fe8/src/Lucene.Net.Tests.QueryParser/Flexible/Spans/SpanOrQueryNodeBuilder.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.QueryParser/Flexible/Spans/SpanOrQueryNodeBuilder.cs b/src/Lucene.Net.Tests.QueryParser/Flexible/Spans/SpanOrQueryNodeBuilder.cs
index fbc5ea7..d9a2953 100644
--- a/src/Lucene.Net.Tests.QueryParser/Flexible/Spans/SpanOrQueryNodeBuilder.cs
+++ b/src/Lucene.Net.Tests.QueryParser/Flexible/Spans/SpanOrQueryNodeBuilder.cs
@@ -48,7 +48,6 @@ namespace Lucene.Net.QueryParsers.Flexible.Spans
             }
 
             return new SpanOrQuery(spanQueries);
-
         }
     }
 }


Mime
View raw message