Skip to content

Apache Lucene open-source search software

javadocs: fix invalid refs in `queryparsers` #14086 (#14087)

Mikhail Khludneva4434ca93c8e
diff --git a/lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/package-info.java b/lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/package-info.java
index 4d20996e41b..f3c1ded1f1f 100644
--- a/lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/package-info.java
+++ b/lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/package-info.java
@@ -15,83 +15,5 @@
* limitations under the License.
*/
-/**
- * Flexible query parser is a modular, extensible framework for implementing Lucene query parsers.
- * In the flexible query parser model, query parsing takes three steps: syntax parsing, processing
- * (query semantics) and building (conversion to a Lucene {@link org.apache.lucene.search.Query}).
- *
- * <p>The flexible query parser module provides not just the framework but also the {@linkplain
- * org.apache.lucene.queryparser.flexible.standard.StandardQueryParser} - the default implementation
- * of a fully fledged query parser that supports most of the classic query parser's syntax but also
- * adds support for interval functions, min-should-match operator on Boolean groups and many hooks
- * for customization of how the parser behaves at runtime.
- *
- * <p>The flexible query parser is divided in two packages:
- *
- * <ul>
- * <li>{@link org.apache.lucene.queryparser.flexible.core}: contains the query parser API classes,
- * which should be extended by custom query parser implementations.
- * <li>{@link org.apache.lucene.queryparser.flexible.standard}: contains an example Lucene query
- * parser implementation built on top of the flexible query parser API.
- * </ul>
- *
- * <h2>Features</h2>
- *
- * <ol>
- * <li>full support for Boolean expressions, including groups
- * <li>{@linkplain org.apache.lucene.queryparser.flexible.core.parser.SyntaxParser syntax parsers}
- * - support for arbitrary syntax parsers, that can be converted into {@link
- * org.apache.lucene.queryparser.flexible.core.nodes.QueryNode} trees.
- * <li>{@linkplain org.apache.lucene.queryparser.flexible.core.processors.QueryNodeProcessor query
- * node processors} - optimize, validate, rewrite the {@link
- * org.apache.lucene.queryparser.flexible.core.nodes.QueryNode} trees
- * <li>{@linkplain
- * org.apache.lucene.queryparser.flexible.core.processors.QueryNodeProcessorPipeline processor
- * pipelines} - select your favorite query processors and build a pipeline to implement the
- * features you need.
- * <li>{@linkplain org.apache.lucene.queryparser.flexible.core.config.QueryConfigHandler query
- * configuration handlers}
- * <li>{@linkplain org.apache.lucene.queryparser.flexible.core.builders.QueryBuilder query
- * builders} - convert {@link org.apache.lucene.queryparser.flexible.core.nodes.QueryNode}
- * trees into Lucene {@link org.apache.lucene.search.Query} instances.
- * </ol>
- *
- * <h2>Design</h2>
- *
- * <p>The flexible query parser was designed to have a very generic architecture, so that it can be
- * easily used for different products with varying query syntax needs.
- *
- * <p>The query parser has three layers and its core is what we call the {@linkplain
- * org.apache.lucene.queryparser.flexible.core.nodes.QueryNode query node tree}. It is a tree of
- * objects that represent the syntax of the original query, for example, for 'a AND b' the tree
- * could look like this:
- *
- * <pre>
- * AND
- * / \
- * A B
- * </pre>
- *
- * <p>The three flexible query parser layers are:
- *
- * <dl>
- * <dt>{@link org.apache.lucene.queryparser.flexible.core.parser.SyntaxParser}
- * <dd>This layer is the text parsing layer which simply transforms the query text string into a
- * {@link org.apache.lucene.queryparser.flexible.core.nodes.QueryNode} tree. Every text parser
- * must implement the interface {@link
- * org.apache.lucene.queryparser.flexible.core.parser.SyntaxParser}. The default
- * implementation is {@link
- * org.apache.lucene.queryparser.flexible.standard.parser.StandardSyntaxParser}.
- * <dt>{@link org.apache.lucene.queryparser.flexible.core.processors.QueryNodeProcessor}
- * <dd>The query node processor does most of the work: it contains a chain of {@linkplain
- * org.apache.lucene.queryparser.flexible.core.processors.QueryNodeProcessor query node
- * processors}. Each processor can walk the tree and modify nodes or even the tree's
- * structure. This allows for query optimization before the node tree is converted to an
- * actual query.
- * <dt>{@link org.apache.lucene.queryparser.flexible.core.builders.QueryBuilder}
- * <dd>The third layer is a configurable map of builders, which map {@linkplain
- * org.apache.lucene.queryparser.flexible.core.nodes.QueryNode query nodes} to their adapters
- * that convert each node into a {@link org.apache.lucene.search.Query}.
- * </dl>
- */
+/** */
package org.apache.lucene.queryparser.flexible;
diff --git a/lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/standard/package-info.java b/lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/standard/package-info.java
index 569df7a029c..9d02e8aff02 100644
--- a/lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/standard/package-info.java
+++ b/lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/standard/package-info.java
@@ -22,10 +22,83 @@
* operations. In the new query parser structure, the parsing was divided in 3 steps: parsing
* (syntax), processing (semantic) and building.
*
- * <p>The classes contained in the package org.apache.lucene.queryParser.standard are used to
- * reproduce the same behavior as the old query parser.
+ * <p>Flexible query parser is a modular, extensible framework for implementing Lucene query
+ * parsers. In the flexible query parser model, query parsing takes three steps: syntax parsing,
+ * processing (query semantics) and building (conversion to a Lucene {@link
+ * org.apache.lucene.search.Query}).
*
- * <p>Check {@link org.apache.lucene.queryparser.flexible.standard.StandardQueryParser} to quick
- * start using the Lucene query parser.
+ * <p>The flexible query parser module provides not just the framework but also the {@linkplain
+ * org.apache.lucene.queryparser.flexible.standard.StandardQueryParser} - the default implementation
+ * of a fully fledged query parser that supports most of the classic query parser's syntax but also
+ * adds support for interval functions, min-should-match operator on Boolean groups and many hooks
+ * for customization of how the parser behaves at runtime.
+ *
+ * <p>The flexible query parser is divided in two packages:
+ *
+ * <ul>
+ * <li>{@link org.apache.lucene.queryparser.flexible.core}: contains the query parser API classes,
+ * which should be extended by custom query parser implementations.
+ * <li>{@link org.apache.lucene.queryparser.flexible.standard}: contains an example Lucene query
+ * parser implementation built on top of the flexible query parser API.
+ * </ul>
+ *
+ * <h2>Features</h2>
+ *
+ * <ol>
+ * <li>full support for Boolean expressions, including groups
+ * <li>{@linkplain org.apache.lucene.queryparser.flexible.core.parser.SyntaxParser syntax parsers}
+ * - support for arbitrary syntax parsers, that can be converted into {@link
+ * org.apache.lucene.queryparser.flexible.core.nodes.QueryNode} trees.
+ * <li>{@linkplain org.apache.lucene.queryparser.flexible.core.processors.QueryNodeProcessor query
+ * node processors} - optimize, validate, rewrite the {@link
+ * org.apache.lucene.queryparser.flexible.core.nodes.QueryNode} trees
+ * <li>{@linkplain
+ * org.apache.lucene.queryparser.flexible.core.processors.QueryNodeProcessorPipeline processor
+ * pipelines} - select your favorite query processors and build a pipeline to implement the
+ * features you need.
+ * <li>{@linkplain org.apache.lucene.queryparser.flexible.core.config.QueryConfigHandler query
+ * configuration handlers}
+ * <li>{@linkplain org.apache.lucene.queryparser.flexible.core.builders.QueryBuilder query
+ * builders} - convert {@link org.apache.lucene.queryparser.flexible.core.nodes.QueryNode}
+ * trees into Lucene {@link org.apache.lucene.search.Query} instances.
+ * </ol>
+ *
+ * <h2>Design</h2>
+ *
+ * <p>The flexible query parser was designed to have a very generic architecture, so that it can be
+ * easily used for different products with varying query syntax needs.
+ *
+ * <p>The query parser has three layers and its core is what we call the {@linkplain
+ * org.apache.lucene.queryparser.flexible.core.nodes.QueryNode query node tree}. It is a tree of
+ * objects that represent the syntax of the original query, for example, for 'a AND b' the tree
+ * could look like this:
+ *
+ * <pre>
+ * AND
+ * / \
+ * A B
+ * </pre>
+ *
+ * <p>The three flexible query parser layers are:
+ *
+ * <dl>
+ * <dt>{@link org.apache.lucene.queryparser.flexible.core.parser.SyntaxParser}
+ * <dd>This layer is the text parsing layer which simply transforms the query text string into a
+ * {@link org.apache.lucene.queryparser.flexible.core.nodes.QueryNode} tree. Every text parser
+ * must implement the interface {@link
+ * org.apache.lucene.queryparser.flexible.core.parser.SyntaxParser}. The default
+ * implementation is {@link
+ * org.apache.lucene.queryparser.flexible.standard.parser.StandardSyntaxParser}.
+ * <dt>{@link org.apache.lucene.queryparser.flexible.core.processors.QueryNodeProcessor}
+ * <dd>The query node processor does most of the work: it contains a chain of {@linkplain
+ * org.apache.lucene.queryparser.flexible.core.processors.QueryNodeProcessor query node
+ * processors}. Each processor can walk the tree and modify nodes or even the tree's
+ * structure. This allows for query optimization before the node tree is converted to an
+ * actual query.
+ * <dt>{@link org.apache.lucene.queryparser.flexible.core.builders.QueryBuilder}
+ * <dd>The third layer is a configurable map of builders, which map {@linkplain
+ * org.apache.lucene.queryparser.flexible.core.nodes.QueryNode query nodes} to their adapters
+ * that convert each node into a {@link org.apache.lucene.search.Query}.
+ * </dl>
*/
package org.apache.lucene.queryparser.flexible.standard;
diff --git a/lucene/queryparser/src/java/overview.html b/lucene/queryparser/src/java/overview.html
index 2b6f8a446af..a7c579dd836 100644
--- a/lucene/queryparser/src/java/overview.html
+++ b/lucene/queryparser/src/java/overview.html
@@ -27,16 +27,16 @@
<p>
This module provides a number of query parsers:
<ul>
- <li>{@linkplain org.apache.lucene.queryparser.flexible flexible query parser}
+ <li>{@linkplain org.apache.lucene.queryparser.flexible.standard flexible query parser}
<li>{@linkplain org.apache.lucene.queryparser.classic classic query parser}
<li>{@linkplain org.apache.lucene.queryparser.complexPhrase complex phrase query parser}
<li>{@linkplain org.apache.lucene.queryparser.ext extendable query parser}
- <li>{@linkplain org.apache.lucene.queryparser.surround surround query parser (span queries)}
+ <li>{@linkplain org.apache.lucene.queryparser.surround.parser surround query parser (span queries)}
<li>{@linkplain org.apache.lucene.queryparser.xml query parser building Query objects from XML}
</ul>
<p>
- If you're new to query parsers, the {@linkplain org.apache.lucene.queryparser.flexible flexible query parser}'s
+ If you're new to query parsers, the {@linkplain org.apache.lucene.queryparser.flexible.standard flexible query parser}'s
{@link org.apache.lucene.queryparser.flexible.standard.StandardQueryParser} is probably a good place to start.
</body>