From 6f66858572c0aa9528e5b1e6999c945db5712fce Mon Sep 17 00:00:00 2001 From: Robert Muir Date: Tue, 19 Oct 2010 20:33:54 +0000 Subject: [PATCH] LUCENE-1937: add methods to manipulate QueryNodeProcessorPipeline elements git-svn-id: https://svn.apache.org/repos/asf/lucene/dev/trunk@1024402 13f79535-47bb-0310-9956-ffa450edef68 --- lucene/contrib/CHANGES.txt | 4 + .../QueryNodeProcessorPipeline.java | 217 +++++++++++++++++- .../StandardQueryNodeProcessorPipeline.java | 34 +-- .../spans/TestSpanQueryParser.java | 8 +- .../TestSpanQueryParserSimpleSample.java | 4 +- .../queryParser/standard/TestQPHelper.java | 2 +- .../standard/TestQueryParserWrapper.java | 6 +- 7 files changed, 237 insertions(+), 38 deletions(-) diff --git a/lucene/contrib/CHANGES.txt b/lucene/contrib/CHANGES.txt index 3f0c67e8461..f001c73cf04 100644 --- a/lucene/contrib/CHANGES.txt +++ b/lucene/contrib/CHANGES.txt @@ -158,6 +158,10 @@ API Changes * LUCENE-2712: FieldBoostMapAttribute in contrib/queryparser was changed from a Map to a Map. Per the CharSequence javadoc, CharSequence is inappropriate as a map key. (Robert Muir) + + * LUCENE-1937: Add more methods to manipulate QueryNodeProcessorPipeline elements. + QueryNodeProcessorPipeline now implements the List interface, this is useful + if you want to extend or modify an existing pipeline. (Adriano Crestani via Robert Muir) New features diff --git a/lucene/contrib/queryparser/src/java/org/apache/lucene/queryParser/core/processors/QueryNodeProcessorPipeline.java b/lucene/contrib/queryparser/src/java/org/apache/lucene/queryParser/core/processors/QueryNodeProcessorPipeline.java index d9e591cb528..7e00e1a0d70 100644 --- a/lucene/contrib/queryparser/src/java/org/apache/lucene/queryParser/core/processors/QueryNodeProcessorPipeline.java +++ b/lucene/contrib/queryparser/src/java/org/apache/lucene/queryParser/core/processors/QueryNodeProcessorPipeline.java @@ -17,7 +17,11 @@ package org.apache.lucene.queryParser.core.processors; * limitations under the License. */ +import java.util.Collection; +import java.util.Iterator; import java.util.LinkedList; +import java.util.List; +import java.util.ListIterator; import org.apache.lucene.queryParser.core.QueryNodeException; import org.apache.lucene.queryParser.core.config.QueryConfigHandler; @@ -33,11 +37,12 @@ import org.apache.lucene.queryParser.core.nodes.QueryNode; * processors were on the pipeline. * * When a {@link QueryConfigHandler} object is set on a - * {@link QueryNodeProcessorPipeline}, it takes care of also setting this + * {@link QueryNodeProcessorPipeline}, it also takes care of setting this * {@link QueryConfigHandler} on all processor on pipeline. * */ -public class QueryNodeProcessorPipeline implements QueryNodeProcessor { +public class QueryNodeProcessorPipeline implements QueryNodeProcessor, + List { private LinkedList processors = new LinkedList(); @@ -74,11 +79,10 @@ public class QueryNodeProcessorPipeline implements QueryNodeProcessor { * For reference about this method check: * {@link QueryNodeProcessor#process(QueryNode)}. * - * @param queryTree - * the query node tree to be processed + * @param queryTree the query node tree to be processed * - * @throws QueryNodeException - * if something goes wrong during the query node processing + * @throws QueryNodeException if something goes wrong during the query node + * processing * * @see QueryNode */ @@ -96,9 +100,12 @@ public class QueryNodeProcessorPipeline implements QueryNodeProcessor { * Adds a processor to the pipeline, it's always added to the end of the * pipeline. * - * @param processor - * the processor to be added + * @deprecated this class now conforms to {@link List} interface, so use + * {@link #add(QueryNodeProcessor)} instead + * + * @param processor the processor to be added */ + @Deprecated public void addProcessor(QueryNodeProcessor processor) { this.processors.add(processor); @@ -110,8 +117,7 @@ public class QueryNodeProcessorPipeline implements QueryNodeProcessor { * For reference about this method check: * {@link QueryNodeProcessor#setQueryConfigHandler(QueryConfigHandler)}. * - * @param queryConfigHandler - * the query configuration handler to be set. + * @param queryConfigHandler the query configuration handler to be set. * * @see QueryNodeProcessor#getQueryConfigHandler() * @see QueryConfigHandler @@ -125,4 +131,195 @@ public class QueryNodeProcessorPipeline implements QueryNodeProcessor { } + /** + * @see List#add(Object) + */ + public boolean add(QueryNodeProcessor processor) { + boolean added = this.processors.add(processor); + + if (added) { + processor.setQueryConfigHandler(this.queryConfig); + } + + return added; + + } + + /** + * @see List#add(int, Object) + */ + public void add(int index, QueryNodeProcessor processor) { + this.processors.add(index, processor); + processor.setQueryConfigHandler(this.queryConfig); + + } + + /** + * @see List#addAll(Collection) + */ + public boolean addAll(Collection c) { + boolean anyAdded = this.processors.addAll(c); + + for (QueryNodeProcessor processor : c) { + processor.setQueryConfigHandler(this.queryConfig); + } + + return anyAdded; + + } + + /** + * @see List#addAll(int, Collection) + */ + public boolean addAll(int index, Collection c) { + boolean anyAdded = this.processors.addAll(index, c); + + for (QueryNodeProcessor processor : c) { + processor.setQueryConfigHandler(this.queryConfig); + } + + return anyAdded; + + } + + /** + * @see List#clear() + */ + public void clear() { + this.processors.clear(); + } + + /** + * @see List#contains(Object) + */ + public boolean contains(Object o) { + return this.processors.contains(o); + } + + /** + * @see List#containsAll(Collection) + */ + public boolean containsAll(Collection c) { + return this.processors.containsAll(c); + } + + /** + * @see List#get(int) + */ + public QueryNodeProcessor get(int index) { + return this.processors.get(index); + } + + /** + * @see List#indexOf(Object) + */ + public int indexOf(Object o) { + return this.processors.indexOf(o); + } + + /** + * @see List#isEmpty() + */ + public boolean isEmpty() { + return this.processors.isEmpty(); + } + + /** + * @see List#iterator() + */ + public Iterator iterator() { + return this.processors.iterator(); + } + + /** + * @see List#lastIndexOf(Object) + */ + public int lastIndexOf(Object o) { + return this.processors.lastIndexOf(o); + } + + /** + * @see List#listIterator() + */ + public ListIterator listIterator() { + return this.processors.listIterator(); + } + + /** + * @see List#listIterator(int) + */ + public ListIterator listIterator(int index) { + return this.processors.listIterator(index); + } + + /** + * @see List#remove(Object) + */ + public boolean remove(Object o) { + return this.processors.remove(o); + } + + /** + * @see List#remove(int) + */ + public QueryNodeProcessor remove(int index) { + return this.processors.remove(index); + } + + /** + * @see List#removeAll(Collection) + */ + public boolean removeAll(Collection c) { + return this.processors.removeAll(c); + } + + /** + * @see List#retainAll(Collection) + */ + public boolean retainAll(Collection c) { + return this.processors.retainAll(c); + } + + /** + * @see List#set(int, Object) + */ + public QueryNodeProcessor set(int index, QueryNodeProcessor processor) { + QueryNodeProcessor oldProcessor = this.processors.set(index, processor); + + if (oldProcessor != processor) { + processor.setQueryConfigHandler(this.queryConfig); + } + + return oldProcessor; + + } + + /** + * @see List#size() + */ + public int size() { + return this.processors.size(); + } + + /** + * @see List#subList(int, int) + */ + public List subList(int fromIndex, int toIndex) { + return this.processors.subList(fromIndex, toIndex); + } + + /** + * @see List#toArray(Object[]) + */ + public T[] toArray(T[] array) { + return this.processors.toArray(array); + } + + /** + * @see List#toArray() + */ + public Object[] toArray() { + return this.processors.toArray(); + } + } diff --git a/lucene/contrib/queryparser/src/java/org/apache/lucene/queryParser/standard/processors/StandardQueryNodeProcessorPipeline.java b/lucene/contrib/queryparser/src/java/org/apache/lucene/queryParser/standard/processors/StandardQueryNodeProcessorPipeline.java index 9ad54517970..029eef9a0f8 100644 --- a/lucene/contrib/queryparser/src/java/org/apache/lucene/queryParser/standard/processors/StandardQueryNodeProcessorPipeline.java +++ b/lucene/contrib/queryparser/src/java/org/apache/lucene/queryParser/standard/processors/StandardQueryNodeProcessorPipeline.java @@ -48,23 +48,23 @@ public class StandardQueryNodeProcessorPipeline extends public StandardQueryNodeProcessorPipeline(QueryConfigHandler queryConfig) { super(queryConfig); - addProcessor(new WildcardQueryNodeProcessor()); - addProcessor(new MultiFieldQueryNodeProcessor()); - addProcessor(new FuzzyQueryNodeProcessor()); - addProcessor(new MatchAllDocsQueryNodeProcessor()); - addProcessor(new LowercaseExpandedTermsQueryNodeProcessor()); - addProcessor(new ParametricRangeQueryNodeProcessor()); - addProcessor(new AllowLeadingWildcardProcessor()); - addProcessor(new AnalyzerQueryNodeProcessor()); - addProcessor(new PhraseSlopQueryNodeProcessor()); - addProcessor(new GroupQueryNodeProcessor()); - addProcessor(new NoChildOptimizationQueryNodeProcessor()); - addProcessor(new RemoveDeletedQueryNodesProcessor()); - addProcessor(new RemoveEmptyNonLeafQueryNodeProcessor()); - addProcessor(new BooleanSingleChildOptimizationQueryNodeProcessor()); - addProcessor(new DefaultPhraseSlopQueryNodeProcessor()); - addProcessor(new BoostQueryNodeProcessor()); - addProcessor(new MultiTermRewriteMethodProcessor()); + add(new WildcardQueryNodeProcessor()); + add(new MultiFieldQueryNodeProcessor()); + add(new FuzzyQueryNodeProcessor()); + add(new MatchAllDocsQueryNodeProcessor()); + add(new LowercaseExpandedTermsQueryNodeProcessor()); + add(new ParametricRangeQueryNodeProcessor()); + add(new AllowLeadingWildcardProcessor()); + add(new AnalyzerQueryNodeProcessor()); + add(new PhraseSlopQueryNodeProcessor()); + add(new GroupQueryNodeProcessor()); + add(new NoChildOptimizationQueryNodeProcessor()); + add(new RemoveDeletedQueryNodesProcessor()); + add(new RemoveEmptyNonLeafQueryNodeProcessor()); + add(new BooleanSingleChildOptimizationQueryNodeProcessor()); + add(new DefaultPhraseSlopQueryNodeProcessor()); + add(new BoostQueryNodeProcessor()); + add(new MultiTermRewriteMethodProcessor()); } } diff --git a/lucene/contrib/queryparser/src/test/org/apache/lucene/queryParser/spans/TestSpanQueryParser.java b/lucene/contrib/queryparser/src/test/org/apache/lucene/queryParser/spans/TestSpanQueryParser.java index 528f02fd778..1cd2a202644 100644 --- a/lucene/contrib/queryparser/src/test/org/apache/lucene/queryParser/spans/TestSpanQueryParser.java +++ b/lucene/contrib/queryparser/src/test/org/apache/lucene/queryParser/spans/TestSpanQueryParser.java @@ -117,11 +117,9 @@ public class TestSpanQueryParser extends LuceneTestCase { this.spanProcessorPipeline .setQueryConfigHandler(this.spanQueryConfigHandler); - this.spanProcessorPipeline.addProcessor(new WildcardQueryNodeProcessor()); - this.spanProcessorPipeline - .addProcessor(new SpansValidatorQueryNodeProcessor()); - this.spanProcessorPipeline - .addProcessor(new UniqueFieldQueryNodeProcessor()); + this.spanProcessorPipeline.add(new WildcardQueryNodeProcessor()); + this.spanProcessorPipeline.add(new SpansValidatorQueryNodeProcessor()); + this.spanProcessorPipeline.add(new UniqueFieldQueryNodeProcessor()); } diff --git a/lucene/contrib/queryparser/src/test/org/apache/lucene/queryParser/spans/TestSpanQueryParserSimpleSample.java b/lucene/contrib/queryparser/src/test/org/apache/lucene/queryParser/spans/TestSpanQueryParserSimpleSample.java index 2f467a00b8c..633a5a2cd27 100644 --- a/lucene/contrib/queryparser/src/test/org/apache/lucene/queryParser/spans/TestSpanQueryParserSimpleSample.java +++ b/lucene/contrib/queryparser/src/test/org/apache/lucene/queryParser/spans/TestSpanQueryParserSimpleSample.java @@ -113,9 +113,9 @@ public class TestSpanQueryParserSimpleSample extends LuceneTestCase { QueryNodeProcessorPipeline spanProcessorPipeline = new QueryNodeProcessorPipeline( spanQueryConfigHandler); // @see SpansValidatorQueryNodeProcessor - spanProcessorPipeline.addProcessor(new SpansValidatorQueryNodeProcessor()); + spanProcessorPipeline.add(new SpansValidatorQueryNodeProcessor()); // @see UniqueFieldQueryNodeProcessor - spanProcessorPipeline.addProcessor(new UniqueFieldQueryNodeProcessor()); + spanProcessorPipeline.add(new UniqueFieldQueryNodeProcessor()); // print to show out the QueryNode tree before being processed if (VERBOSE) System.out.println(queryTree); diff --git a/lucene/contrib/queryparser/src/test/org/apache/lucene/queryParser/standard/TestQPHelper.java b/lucene/contrib/queryparser/src/test/org/apache/lucene/queryParser/standard/TestQPHelper.java index 12c763c75cf..1d3deddac9c 100644 --- a/lucene/contrib/queryparser/src/test/org/apache/lucene/queryParser/standard/TestQPHelper.java +++ b/lucene/contrib/queryparser/src/test/org/apache/lucene/queryParser/standard/TestQPHelper.java @@ -138,7 +138,7 @@ public class TestQPHelper extends LuceneTestCase { public static class QPTestParser extends StandardQueryParser { public QPTestParser(Analyzer a) { ((QueryNodeProcessorPipeline)getQueryNodeProcessor()) - .addProcessor(new QPTestParserQueryNodeProcessor()); + .add(new QPTestParserQueryNodeProcessor()); this.setAnalyzer(a); } diff --git a/lucene/contrib/queryparser/src/test/org/apache/lucene/queryParser/standard/TestQueryParserWrapper.java b/lucene/contrib/queryparser/src/test/org/apache/lucene/queryParser/standard/TestQueryParserWrapper.java index 2660b701127..9bf672b7112 100644 --- a/lucene/contrib/queryparser/src/test/org/apache/lucene/queryParser/standard/TestQueryParserWrapper.java +++ b/lucene/contrib/queryparser/src/test/org/apache/lucene/queryParser/standard/TestQueryParserWrapper.java @@ -139,9 +139,9 @@ public class TestQueryParserWrapper extends LuceneTestCase { QueryNodeProcessorPipeline newProcessorPipeline = new QueryNodeProcessorPipeline( getQueryProcessor().getQueryConfigHandler()); - newProcessorPipeline.addProcessor(new WildcardQueryNodeProcessor()); - newProcessorPipeline.addProcessor(new QPTestParserQueryNodeProcessor()); - newProcessorPipeline.addProcessor(getQueryProcessor()); + newProcessorPipeline.add(new WildcardQueryNodeProcessor()); + newProcessorPipeline.add(new QPTestParserQueryNodeProcessor()); + newProcessorPipeline.add(getQueryProcessor()); setQueryProcessor(newProcessorPipeline);