Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.lucene.queryparser.flexible.core; import org.apache.lucene.queryparser.flexible.core.builders.QueryBuilder; import org.apache.lucene.queryparser.flexible.core.config.QueryConfigHandler; import org.apache.lucene.queryparser.flexible.core.nodes.QueryNode; import org.apache.lucene.queryparser.flexible.core.parser.SyntaxParser; import org.apache.lucene.queryparser.flexible.core.processors.QueryNodeProcessor; /** * This class is a helper for the query parser framework, it does all the three * query parser phrases at once: text parsing, query processing and query * building. * <p> * It contains methods that allows the user to change the implementation used on * the three phases. * * @see QueryNodeProcessor * @see SyntaxParser * @see QueryBuilder * @see QueryConfigHandler */ public class QueryParserHelper { private QueryNodeProcessor processor; private SyntaxParser syntaxParser; private QueryBuilder builder; private QueryConfigHandler config; /** * Creates a query parser helper object using the specified configuration, * text parser, processor and builder. * * @param queryConfigHandler * the query configuration handler that will be initially set to this * helper * @param syntaxParser * the text parser that will be initially set to this helper * @param processor * the query processor that will be initially set to this helper * @param builder * the query builder that will be initially set to this helper * * @see QueryNodeProcessor * @see SyntaxParser * @see QueryBuilder * @see QueryConfigHandler */ public QueryParserHelper(QueryConfigHandler queryConfigHandler, SyntaxParser syntaxParser, QueryNodeProcessor processor, QueryBuilder builder) { this.syntaxParser = syntaxParser; this.config = queryConfigHandler; this.processor = processor; this.builder = builder; if (processor != null) { processor.setQueryConfigHandler(queryConfigHandler); } } /** * Returns the processor object used to process the query node tree, it * returns <code>null</code> if no processor is used. * * @return the actual processor used to process the query node tree, * <code>null</code> if no processor is used * * @see QueryNodeProcessor * @see #setQueryNodeProcessor(QueryNodeProcessor) */ public QueryNodeProcessor getQueryNodeProcessor() { return processor; } /** * Sets the processor that will be used to process the query node tree. If * there is any {@link QueryConfigHandler} returned by * {@link #getQueryConfigHandler()}, it will be set on the processor. The * argument can be <code>null</code>, which means that no processor will be * used to process the query node tree. * * @param processor * the processor that will be used to process the query node tree, * this argument can be <code>null</code> * * @see #getQueryNodeProcessor() * @see QueryNodeProcessor */ public void setQueryNodeProcessor(QueryNodeProcessor processor) { this.processor = processor; this.processor.setQueryConfigHandler(getQueryConfigHandler()); } /** * Sets the text parser that will be used to parse the query string, it cannot * be <code>null</code>. * * @param syntaxParser * the text parser that will be used to parse the query string * * @see #getSyntaxParser() * @see SyntaxParser */ public void setSyntaxParser(SyntaxParser syntaxParser) { if (syntaxParser == null) { throw new IllegalArgumentException("textParser should not be null!"); } this.syntaxParser = syntaxParser; } /** * The query builder that will be used to build an object from the query node * tree. It cannot be <code>null</code>. * * @param queryBuilder * the query builder used to build something from the query node tree * * @see #getQueryBuilder() * @see QueryBuilder */ public void setQueryBuilder(QueryBuilder queryBuilder) { if (queryBuilder == null) { throw new IllegalArgumentException("queryBuilder should not be null!"); } this.builder = queryBuilder; } /** * Returns the query configuration handler, which is used during the query * node tree processing. It can be <code>null</code>. * * @return the query configuration handler used on the query processing, * <code>null</code> if not query configuration handler is defined * * @see QueryConfigHandler * @see #setQueryConfigHandler(QueryConfigHandler) */ public QueryConfigHandler getQueryConfigHandler() { return config; } /** * Returns the query builder used to build a object from the query node tree. * The object produced by this builder is returned by * {@link #parse(String, String)}. * * @return the query builder * * @see #setQueryBuilder(QueryBuilder) * @see QueryBuilder */ public QueryBuilder getQueryBuilder() { return this.builder; } /** * Returns the text parser used to build a query node tree from a query * string. The default text parser instance returned by this method is a * {@link SyntaxParser}. * * @return the text parse used to build query node trees. * * @see SyntaxParser * @see #setSyntaxParser(SyntaxParser) */ public SyntaxParser getSyntaxParser() { return this.syntaxParser; } /** * Sets the query configuration handler that will be used during query * processing. It can be <code>null</code>. It's also set to the processor * returned by {@link #getQueryNodeProcessor()}. * * @param config * the query configuration handler used during query processing, it * can be <code>null</code> * * @see #getQueryConfigHandler() * @see QueryConfigHandler */ public void setQueryConfigHandler(QueryConfigHandler config) { this.config = config; QueryNodeProcessor processor = getQueryNodeProcessor(); if (processor != null) { processor.setQueryConfigHandler(config); } } /** * Parses a query string to an object, usually some query object.<br> * <br> * In this method the three phases are executed: <br> * <br> * 1st - the query string is parsed using the * text parser returned by {@link #getSyntaxParser()}, the result is a query * node tree <br> * <br> * 2nd - the query node tree is processed by the * processor returned by {@link #getQueryNodeProcessor()} <br> * <br> * 3th - a object is built from the query node * tree using the builder returned by {@link #getQueryBuilder()} * * @param query * the query string * @param defaultField * the default field used by the text parser * * @return the object built from the query * * @throws QueryNodeException * if something wrong happens along the three phases */ public Object parse(String query, String defaultField) throws QueryNodeException { QueryNode queryTree = getSyntaxParser().parse(query, defaultField); QueryNodeProcessor processor = getQueryNodeProcessor(); if (processor != null) { queryTree = processor.process(queryTree); } return getQueryBuilder().build(queryTree); } }