--- /dev/null
+package org.apache.lucene.queryParser.standard;
+
+/**
+ * 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.
+ */
+
+import java.text.Collator;
+import java.util.Locale;
+import java.util.Map;
+import java.util.TooManyListenersException;
+
+import org.apache.lucene.analysis.Analyzer;
+import org.apache.lucene.document.DateTools.Resolution;
+import org.apache.lucene.document.DateTools;
+import org.apache.lucene.queryParser.core.QueryNodeException;
+import org.apache.lucene.queryParser.core.QueryParserHelper;
+import org.apache.lucene.queryParser.core.config.QueryConfigHandler;
+import org.apache.lucene.queryParser.standard.builders.StandardQueryTreeBuilder;
+import org.apache.lucene.queryParser.standard.config.AllowLeadingWildcardAttribute;
+import org.apache.lucene.queryParser.standard.config.AnalyzerAttribute;
+import org.apache.lucene.queryParser.standard.config.DateResolutionAttribute;
+import org.apache.lucene.queryParser.standard.config.DefaultOperatorAttribute;
+import org.apache.lucene.queryParser.standard.config.DefaultPhraseSlopAttribute;
+import org.apache.lucene.queryParser.standard.config.FieldBoostMapAttribute;
+import org.apache.lucene.queryParser.standard.config.FieldDateResolutionMapAttribute;
+import org.apache.lucene.queryParser.standard.config.FuzzyAttribute;
+import org.apache.lucene.queryParser.standard.config.FuzzyConfig;
+import org.apache.lucene.queryParser.standard.config.LocaleAttribute;
+import org.apache.lucene.queryParser.standard.config.LowercaseExpandedTermsAttribute;
+import org.apache.lucene.queryParser.standard.config.MultiFieldAttribute;
+import org.apache.lucene.queryParser.standard.config.MultiTermRewriteMethodAttribute;
+import org.apache.lucene.queryParser.standard.config.NumericConfig;
+import org.apache.lucene.queryParser.standard.config.PositionIncrementsAttribute;
+import org.apache.lucene.queryParser.standard.config.RangeCollatorAttribute;
+import org.apache.lucene.queryParser.standard.config.StandardQueryConfigHandler;
+import org.apache.lucene.queryParser.standard.config.StandardQueryConfigHandler.Operator;
+import org.apache.lucene.queryParser.standard.config.StandardQueryConfigHandler.ConfigurationKeys;
+import org.apache.lucene.queryParser.standard.nodes.RangeQueryNode;
+import org.apache.lucene.queryParser.standard.parser.StandardSyntaxParser;
+import org.apache.lucene.queryParser.standard.processors.StandardQueryNodeProcessorPipeline;
+import org.apache.lucene.search.FuzzyQuery;
+import org.apache.lucene.search.MultiTermQuery;
+import org.apache.lucene.search.Query;
+
+/**
+ * <p>
+ * This class is a helper that enables users to easily use the Lucene query
+ * parser.
+ * </p>
+ * <p>
+ * To construct a Query object from a query string, use the
+ * {@link #parse(String, String)} method:
+ * <ul>
+ * StandardQueryParser queryParserHelper = new StandardQueryParser(); <br/>
+ * Query query = queryParserHelper.parse("a AND b", "defaultField");
+ * </ul>
+ * <p>
+ * To change any configuration before parsing the query string do, for example:
+ * <p/>
+ * <ul>
+ * // the query config handler returned by {@link StandardQueryParser} is a
+ * {@link StandardQueryConfigHandler} <br/>
+ * queryParserHelper.getQueryConfigHandler().setAnalyzer(new
+ * WhitespaceAnalyzer());
+ * </ul>
+ * <p>
+ * The syntax for query strings is as follows (copied from the old QueryParser
+ * javadoc):
+ * <ul>
+ * A Query is a series of clauses. A clause may be prefixed by:
+ * <ul>
+ * <li>a plus (<code>+</code>) or a minus (<code>-</code>) sign, indicating that
+ * the clause is required or prohibited respectively; or
+ * <li>a term followed by a colon, indicating the field to be searched. This
+ * enables one to construct queries which search multiple fields.
+ * </ul>
+ *
+ * A clause may be either:
+ * <ul>
+ * <li>a term, indicating all the documents that contain this term; or
+ * <li>a nested query, enclosed in parentheses. Note that this may be used with
+ * a <code>+</code>/<code>-</code> prefix to require any of a set of terms.
+ * </ul>
+ *
+ * Thus, in BNF, the query grammar is:
+ *
+ * <pre>
+ * Query ::= ( Clause )*
+ * Clause ::= ["+", "-"] [<TERM> ":"] ( <TERM> | "(" Query ")" )
+ * </pre>
+ *
+ * <p>
+ * Examples of appropriately formatted queries can be found in the <a
+ * href="../../../../../../queryparsersyntax.html">query syntax
+ * documentation</a>.
+ * </p>
+ * </ul>
+ * <p>
+ * The text parser used by this helper is a {@link StandardSyntaxParser}.
+ * <p/>
+ * <p>
+ * The query node processor used by this helper is a
+ * {@link StandardQueryNodeProcessorPipeline}.
+ * <p/>
+ * <p>
+ * The builder used by this helper is a {@link StandardQueryTreeBuilder}.
+ * <p/>
+ *
+ * @see StandardQueryParser
+ * @see StandardQueryConfigHandler
+ * @see StandardSyntaxParser
+ * @see StandardQueryNodeProcessorPipeline
+ * @see StandardQueryTreeBuilder
+ */
+public class StandardQueryParser extends QueryParserHelper {
+
+ /**
+ * Constructs a {@link StandardQueryParser} object.
+ */
+ public StandardQueryParser() {
+ super(new StandardQueryConfigHandler(), new StandardSyntaxParser(),
+ new StandardQueryNodeProcessorPipeline(null),
+ new StandardQueryTreeBuilder());
+ }
+
+ /**
+ * Constructs a {@link StandardQueryParser} object and sets an
+ * {@link Analyzer} to it. The same as:
+ *
+ * <ul>
+ * StandardQueryParser qp = new StandardQueryParser();
+ * qp.getQueryConfigHandler().setAnalyzer(analyzer);
+ * </ul>
+ *
+ * @param analyzer the analyzer to be used by this query parser helper
+ */
+ public StandardQueryParser(Analyzer analyzer) {
+ this();
+
+ this.setAnalyzer(analyzer);
+ }
+
+ @Override
+ public String toString() {
+ return "<StandardQueryParser config=\"" + this.getQueryConfigHandler()
+ + "\"/>";
+ }
+
+ /**
+ * Overrides {@link QueryParserHelper#parse(String, String)} so it casts the
+ * return object to {@link Query}. For more reference about this method, check
+ * {@link QueryParserHelper#parse(String, String)}.
+ *
+ * @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
+ */
+ @Override
+ public Query parse(String query, String defaultField)
+ throws QueryNodeException {
+
+ return (Query) super.parse(query, defaultField);
+
+ }
+
+ /**
+ * Gets implicit operator setting, which will be either {@link Operator#AND}
+ * or {@link Operator#OR}.
+ */
+ public StandardQueryConfigHandler.Operator getDefaultOperator() {
+ return getQueryConfigHandler().get(ConfigurationKeys.DEFAULT_OPERATOR);
+ }
+
+ /**
+ * Sets the collator used to determine index term inclusion in ranges for
+ * RangeQuerys.
+ * <p/>
+ * <strong>WARNING:</strong> Setting the rangeCollator to a non-null collator
+ * using this method will cause every single index Term in the Field
+ * referenced by lowerTerm and/or upperTerm to be examined. Depending on the
+ * number of index Terms in this Field, the operation could be very slow.
+ *
+ * @param collator the collator to use when constructing
+ * {@link RangeQueryNode}s
+ */
+ public void setRangeCollator(Collator collator) {
+ RangeCollatorAttribute attr = getQueryConfigHandler().getAttribute(
+ RangeCollatorAttribute.class);
+ attr.setDateResolution(collator);
+
+ // uncomment code below when deprecated query parser attributes are removed
+ // getQueryConfigHandler().set(ConfigurationKeys.RANGE_COLLATOR, collator);
+ }
+
+ /**
+ * @return the collator used to determine index term inclusion in ranges for
+ * RangeQuerys.
+ */
+ public Collator getRangeCollator() {
+ return getQueryConfigHandler().get(ConfigurationKeys.RANGE_COLLATOR);
+ }
+
+ /**
+ * Sets the boolean operator of the QueryParser. In default mode (
+ * {@link Operator#OR}) terms without any modifiers are considered optional:
+ * for example <code>capital of Hungary</code> is equal to
+ * <code>capital OR of OR Hungary</code>.<br/>
+ * In {@link Operator#AND} mode terms are considered to be in conjunction: the
+ * above mentioned query is parsed as <code>capital AND of AND Hungary</code>
+ *
+ * @deprecated
+ */
+ @Deprecated
+ public void setDefaultOperator(DefaultOperatorAttribute.Operator operator) {
+ DefaultOperatorAttribute attr = getQueryConfigHandler().getAttribute(DefaultOperatorAttribute.class);
+ attr.setOperator(operator);
+ }
+
+ /**
+ * Sets the boolean operator of the QueryParser. In default mode (
+ * {@link Operator#OR}) terms without any modifiers are considered optional:
+ * for example <code>capital of Hungary</code> is equal to
+ * <code>capital OR of OR Hungary</code>.<br/>
+ * In {@link Operator#AND} mode terms are considered to be in conjunction: the
+ * above mentioned query is parsed as <code>capital AND of AND Hungary</code>
+ */
+ public void setDefaultOperator(
+ org.apache.lucene.queryParser.standard.config.StandardQueryConfigHandler.Operator operator) {
+
+ DefaultOperatorAttribute.Operator attrOperator;
+
+ if (operator == org.apache.lucene.queryParser.standard.config.StandardQueryConfigHandler.Operator.AND) {
+ attrOperator = DefaultOperatorAttribute.Operator.AND;
+ } else {
+ attrOperator = DefaultOperatorAttribute.Operator.OR;
+ }
+
+ setDefaultOperator(attrOperator);
+
+ // uncomment code below when deprecated query parser attributes are removed
+ // getQueryConfigHandler().set(ConfigurationKeys.DEFAULT_OPERATOR, operator);
+ }
+
+ /**
+ * Set to <code>true</code> to allow leading wildcard characters.
+ * <p>
+ * When set, <code>*</code> or <code>?</code> are allowed as the first
+ * character of a PrefixQuery and WildcardQuery. Note that this can produce
+ * very slow queries on big indexes.
+ * <p>
+ * Default: false.
+ */
+ public void setLowercaseExpandedTerms(boolean lowercaseExpandedTerms) {
+ LowercaseExpandedTermsAttribute attr = getQueryConfigHandler()
+ .getAttribute(LowercaseExpandedTermsAttribute.class);
+ attr.setLowercaseExpandedTerms(lowercaseExpandedTerms);
+ // uncomment code below when deprecated query parser attributes are removed
+ // getQueryConfigHandler().set(ConfigurationKeys.LOWERCASE_EXPANDED_TERMS,
+ // lowercaseExpandedTerms);
+ }
+
+ /**
+ * @see #setLowercaseExpandedTerms(boolean)
+ */
+ public boolean getLowercaseExpandedTerms() {
+ Boolean lowercaseExpandedTerms = getQueryConfigHandler().get(
+ ConfigurationKeys.LOWERCASE_EXPANDED_TERMS);
+
+ if (lowercaseExpandedTerms == null) {
+ return true;
+
+ } else {
+ return lowercaseExpandedTerms;
+ }
+
+ }
+
+ /**
+ * Set to <code>true</code> to allow leading wildcard characters.
+ * <p>
+ * When set, <code>*</code> or <code>?</code> are allowed as the first
+ * character of a PrefixQuery and WildcardQuery. Note that this can produce
+ * very slow queries on big indexes.
+ * <p>
+ * Default: false.
+ */
+ public void setAllowLeadingWildcard(boolean allowLeadingWildcard) {
+ AllowLeadingWildcardAttribute attr = getQueryConfigHandler().getAttribute(
+ AllowLeadingWildcardAttribute.class);
+ attr.setAllowLeadingWildcard(allowLeadingWildcard);
+ // uncomment code below when deprecated query parser attributes are removed
+ // getQueryConfigHandler().set(ConfigurationKeys.ALLOW_LEADING_WILDCARD,
+ // allowLeadingWildcard);
+ }
+
+ /**
+ * Set to <code>true</code> to enable position increments in result query.
+ * <p>
+ * When set, result phrase and multi-phrase queries will be aware of position
+ * increments. Useful when e.g. a StopFilter increases the position increment
+ * of the token that follows an omitted token.
+ * <p>
+ * Default: false.
+ */
+ public void setEnablePositionIncrements(boolean enabled) {
+ PositionIncrementsAttribute attr = getQueryConfigHandler().getAttribute(
+ PositionIncrementsAttribute.class);
+ attr.setPositionIncrementsEnabled(enabled);
+ // uncomment code below when deprecated query parser attributes are removed
+ // getQueryConfigHandler().set(ConfigurationKeys.ENABLE_POSITION_INCREMENTS,
+ // enabled);
+ }
+
+ /**
+ * @see #setEnablePositionIncrements(boolean)
+ */
+ public boolean getEnablePositionIncrements() {
+ Boolean enablePositionsIncrements = getQueryConfigHandler().get(
+ ConfigurationKeys.ENABLE_POSITION_INCREMENTS);
+
+ if (enablePositionsIncrements == null) {
+ return false;
+
+ } else {
+ return enablePositionsIncrements;
+ }
+
+ }
+
+ /**
+ * By default, it uses
+ * {@link MultiTermQuery#CONSTANT_SCORE_AUTO_REWRITE_DEFAULT} when creating a
+ * prefix, wildcard and range queries. This implementation is generally
+ * preferable because it a) Runs faster b) Does not have the scarcity of terms
+ * unduly influence score c) avoids any {@link TooManyListenersException}
+ * exception. However, if your application really needs to use the
+ * old-fashioned boolean queries expansion rewriting and the above points are
+ * not relevant then use this change the rewrite method.
+ */
+ public void setMultiTermRewriteMethod(MultiTermQuery.RewriteMethod method) {
+ MultiTermRewriteMethodAttribute attr = getQueryConfigHandler()
+ .getAttribute(MultiTermRewriteMethodAttribute.class);
+ attr.setMultiTermRewriteMethod(method);
+ // uncomment code below when deprecated query parser attributes are removed
+ // getQueryConfigHandler().set(ConfigurationKeys.MULTI_TERM_REWRITE_METHOD,
+ // method);
+ }
+
+ /**
+ * @see #setMultiTermRewriteMethod(org.apache.lucene.search.MultiTermQuery.RewriteMethod)
+ */
+ public MultiTermQuery.RewriteMethod getMultiTermRewriteMethod() {
+ return getQueryConfigHandler().get(
+ ConfigurationKeys.MULTI_TERM_REWRITE_METHOD);
+ }
+
+ /**
+ * Set the fields a query should be expanded to when the field is
+ * <code>null</code>
+ *
+ * @param fields the fields used to expand the query
+ */
+ public void setMultiFields(CharSequence[] fields) {
+
+ if (fields == null) {
+ fields = new CharSequence[0];
+ }
+
+ MultiFieldAttribute attr = getQueryConfigHandler().addAttribute(
+ MultiFieldAttribute.class);
+ attr.setFields(fields);
+ // uncomment code below when deprecated query parser attributes are removed
+ // getQueryConfigHandler().set(ConfigurationKeys.MULTI_FIELDS, fields);
+
+ }
+
+ /**
+ * Returns the fields used to expand the query when the field for a certain
+ * query is <code>null</code>
+ *
+ * @param fields the fields used to expand the query
+ */
+ public void getMultiFields(CharSequence[] fields) {
+ getQueryConfigHandler().get(ConfigurationKeys.MULTI_FIELDS);
+ }
+
+ /**
+ * Set the prefix length for fuzzy queries. Default is 0.
+ *
+ * @param fuzzyPrefixLength The fuzzyPrefixLength to set.
+ */
+ public void setFuzzyPrefixLength(int fuzzyPrefixLength) {
+ FuzzyAttribute attr = getQueryConfigHandler().addAttribute(
+ FuzzyAttribute.class);
+ attr.setPrefixLength(fuzzyPrefixLength);
+
+ // uncomment code below when deprecated query parser attributes are removed
+ /*
+ * QueryConfigHandler config = getQueryConfigHandler(); FuzzyConfig
+ * fuzzyConfig = config.get(ConfigurationKeys.FUZZY_CONFIG);
+ *
+ * if (fuzzyConfig == null) { fuzzyConfig = new FuzzyConfig();
+ * config.set(ConfigurationKeys.FUZZY_CONFIG, fuzzyConfig); }
+ *
+ * fuzzyConfig.setPrefixLength(fuzzyPrefixLength);
+ */
+ }
+
+ public void setNumericConfigMap(Map<String, NumericConfig> numericConfigMap) {
+ getQueryConfigHandler().set(ConfigurationKeys.NUMERIC_CONFIG_MAP,
+ numericConfigMap);
+ }
+
+ public Map<String, NumericConfig> getNumericConfigMap() {
+ return getQueryConfigHandler().get(ConfigurationKeys.NUMERIC_CONFIG_MAP);
+ }
+
+ /**
+ * Set locale used by date range parsing.
+ */
+ public void setLocale(Locale locale) {
+ LocaleAttribute attr = getQueryConfigHandler().addAttribute(
+ LocaleAttribute.class);
+ attr.setLocale(locale);
+ // uncomment code below when deprecated query parser attributes are removed
+ // getQueryConfigHandler().set(ConfigurationKeys.LOCALE, locale);
+ }
+
+ /**
+ * Returns current locale, allowing access by subclasses.
+ */
+ public Locale getLocale() {
+ return getQueryConfigHandler().get(ConfigurationKeys.LOCALE);
+ }
+
+ /**
+ * Sets the default slop for phrases. If zero, then exact phrase matches are
+ * required. Default value is zero.
+ *
+ * @deprecated renamed to {@link #setPhraseSlop(int)}
+ */
+ @Deprecated
+ public void setDefaultPhraseSlop(int defaultPhraseSlop) {
+ setPhraseSlop(defaultPhraseSlop);
+ }
+
+ /**
+ * Sets the default slop for phrases. If zero, then exact phrase matches are
+ * required. Default value is zero.
+ */
+ public void setPhraseSlop(int defaultPhraseSlop) {
+ DefaultPhraseSlopAttribute attr = getQueryConfigHandler().addAttribute(
+ DefaultPhraseSlopAttribute.class);
+ attr.setDefaultPhraseSlop(defaultPhraseSlop);
+ // uncomment code below when deprecated query parser attributes are removed
+ // getQueryConfigHandler().set(ConfigurationKeys.PHRASE_SLOP,
+ // defaultPhraseSlop);
+ }
+
+ public void setAnalyzer(Analyzer analyzer) {
+ AnalyzerAttribute attr = getQueryConfigHandler().getAttribute(
+ AnalyzerAttribute.class);
+ attr.setAnalyzer(analyzer);
+ // uncomment code below when deprecated query parser attributes are removed
+ // getQueryConfigHandler().set(ConfigurationKeys.ANALYZER, analyzer);
+ }
+
+ public Analyzer getAnalyzer() {
+ return getQueryConfigHandler().get(ConfigurationKeys.ANALYZER);
+ }
+
+ /**
+ * @see #setAllowLeadingWildcard(boolean)
+ */
+ public boolean getAllowLeadingWildcard() {
+ Boolean allowLeadingWildcard = getQueryConfigHandler().get(
+ ConfigurationKeys.ALLOW_LEADING_WILDCARD);
+
+ if (allowLeadingWildcard == null) {
+ return false;
+
+ } else {
+ return allowLeadingWildcard;
+ }
+ }
+
+ /**
+ * Get the minimal similarity for fuzzy queries.
+ */
+ public float getFuzzyMinSim() {
+ FuzzyConfig fuzzyConfig = getQueryConfigHandler().get(
+ ConfigurationKeys.FUZZY_CONFIG);
+
+ if (fuzzyConfig == null) {
+ return FuzzyQuery.defaultMinSimilarity;
+ } else {
+ return fuzzyConfig.getMinSimilarity();
+ }
+ }
+
+ /**
+ * Get the prefix length for fuzzy queries.
+ *
+ * @return Returns the fuzzyPrefixLength.
+ */
+ public int getFuzzyPrefixLength() {
+ FuzzyConfig fuzzyConfig = getQueryConfigHandler().get(
+ ConfigurationKeys.FUZZY_CONFIG);
+
+ if (fuzzyConfig == null) {
+ return FuzzyQuery.defaultPrefixLength;
+ } else {
+ return fuzzyConfig.getPrefixLength();
+ }
+ }
+
+ /**
+ * Gets the default slop for phrases.
+ */
+ public int getPhraseSlop() {
+ Integer phraseSlop = getQueryConfigHandler().get(
+ ConfigurationKeys.PHRASE_SLOP);
+
+ if (phraseSlop == null) {
+ return 0;
+
+ } else {
+ return phraseSlop;
+ }
+ }
+
+ /**
+ * Set the minimum similarity for fuzzy queries. Default is defined on
+ * {@link FuzzyQuery#defaultMinSimilarity}.
+ */
+ public void setFuzzyMinSim(float fuzzyMinSim) {
+ FuzzyAttribute attr = getQueryConfigHandler().addAttribute(
+ FuzzyAttribute.class);
+ attr.setFuzzyMinSimilarity(fuzzyMinSim);
+ // uncomment code below when deprecated query parser attributes are removed
+ /*
+ * QueryConfigHandler config = getQueryConfigHandler(); FuzzyConfig
+ * fuzzyConfig = config.get(ConfigurationKeys.FUZZY_CONFIG);
+ *
+ * if (fuzzyConfig == null) { fuzzyConfig = new FuzzyConfig();
+ * config.set(ConfigurationKeys.FUZZY_CONFIG, fuzzyConfig); }
+ *
+ * fuzzyConfig.setMinSimilarity(fuzzyMinSim);
+ */
+ }
+
+ /**
+ * Sets the boost used for each field.
+ *
+ * @param boosts a collection that maps a field to its boost
+ */
+ public void setFieldsBoost(Map<String, Float> boosts) {
+ FieldBoostMapAttribute attr = getQueryConfigHandler().addAttribute(
+ FieldBoostMapAttribute.class);
+ attr.setFieldBoostMap(boosts);
+ // uncomment code below when deprecated query parser attributes are removed
+ // getQueryConfigHandler().set(ConfigurationKeys.FIELD_BOOST_MAP, boosts);
+ }
+
+ /**
+ * Returns the field to boost map used to set boost for each field.
+ *
+ * @return the field to boost map
+ */
+ public Map<String, Float> getFieldsBoost() {
+ return getQueryConfigHandler().get(ConfigurationKeys.FIELD_BOOST_MAP);
+ }
+
+ /**
+ * Sets the default {@link Resolution} used for certain field when no
+ * {@link Resolution} is defined for this field.
+ *
+ * @param dateResolution the default {@link Resolution}
+ */
+ public void setDateResolution(DateTools.Resolution dateResolution) {
+ DateResolutionAttribute attr = getQueryConfigHandler().addAttribute(
+ DateResolutionAttribute.class);
+ attr.setDateResolution(dateResolution);
+ // uncomment code below when deprecated query parser attributes are removed
+ // getQueryConfigHandler().set(ConfigurationKeys.DATE_RESOLUTION,
+ // dateResolution);
+ }
+
+ /**
+ * Returns the default {@link Resolution} used for certain field when no
+ * {@link Resolution} is defined for this field.
+ *
+ * @return the default {@link Resolution}
+ */
+ public DateTools.Resolution getDateResolution() {
+ return getQueryConfigHandler().get(ConfigurationKeys.DATE_RESOLUTION);
+ }
+
+ /**
+ * Sets the {@link Resolution} used for each field
+ *
+ * @param dateRes a collection that maps a field to its {@link Resolution}
+ *
+ * @deprecated this method was renamed to {@link #setDateResolutionMap(Map)}
+ */
+ @Deprecated
+ public void setDateResolution(Map<CharSequence, DateTools.Resolution> dateRes) {
+ setDateResolutionMap(dateRes);
+ }
+
+ /**
+ * Returns the field to {@link Resolution} map used to normalize each date
+ * field.
+ *
+ * @return the field to {@link Resolution} map
+ */
+ public Map<CharSequence, DateTools.Resolution> getDateResolutionMap() {
+ return getQueryConfigHandler().get(
+ ConfigurationKeys.FIELD_DATE_RESOLUTION_MAP);
+ }
+
+ /**
+ * Sets the {@link Resolution} used for each field
+ *
+ * @param dateRes a collection that maps a field to its {@link Resolution}
+ */
+ public void setDateResolutionMap(
+ Map<CharSequence, DateTools.Resolution> dateRes) {
+ FieldDateResolutionMapAttribute attr = getQueryConfigHandler()
+ .addAttribute(FieldDateResolutionMapAttribute.class);
+ attr.setFieldDateResolutionMap(dateRes);
+ // uncomment code below when deprecated query parser attributes are removed
+ // getQueryConfigHandler().set(ConfigurationKeys.FIELD_DATE_RESOLUTION_MAP,
+ // dateRes);
+ }
+
+}
fnp / pylucene.git / blobdiff