You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucenenet.apache.org by ni...@apache.org on 2016/12/06 15:12:14 UTC
[39/58] lucenenet git commit: QueryParser.Flexible: Documentation
comments
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 = {"filename", "contents", "description"};
- * 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: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 = {"filename", "contents", "description"};
+ /// 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: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 = {"query1", "query2", "query3"};
- * String[] fields = {"filename", "contents", "description"};
- * 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 = {"query1", "query2", "query3"};
+ /// string[] fields = {"filename", "contents", "description"};
+ /// 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 ::= ["+", "-"] [<TERM> ":"] ( <TERM> | "(" Query ")" )
+ /// </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);
-
}
}
}