Index: lucene/contrib/queryparser/src/test/org/apache/lucene/queryParser/standard/TestQPHelper.java =================================================================== --- lucene/contrib/queryparser/src/test/org/apache/lucene/queryParser/standard/TestQPHelper.java (revision 1024219) +++ lucene/contrib/queryparser/src/test/org/apache/lucene/queryParser/standard/TestQPHelper.java (working copy) @@ -138,7 +138,7 @@ public static class QPTestParser extends StandardQueryParser { public QPTestParser(Analyzer a) { ((QueryNodeProcessorPipeline)getQueryNodeProcessor()) - .addProcessor(new QPTestParserQueryNodeProcessor()); + .add(new QPTestParserQueryNodeProcessor()); this.setAnalyzer(a); } Index: lucene/contrib/queryparser/src/test/org/apache/lucene/queryParser/standard/TestQueryParserWrapper.java =================================================================== --- lucene/contrib/queryparser/src/test/org/apache/lucene/queryParser/standard/TestQueryParserWrapper.java (revision 1024219) +++ lucene/contrib/queryparser/src/test/org/apache/lucene/queryParser/standard/TestQueryParserWrapper.java (working copy) @@ -139,9 +139,9 @@ 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); Index: lucene/contrib/queryparser/src/test/org/apache/lucene/queryParser/spans/TestSpanQueryParserSimpleSample.java =================================================================== --- lucene/contrib/queryparser/src/test/org/apache/lucene/queryParser/spans/TestSpanQueryParserSimpleSample.java (revision 1023895) +++ lucene/contrib/queryparser/src/test/org/apache/lucene/queryParser/spans/TestSpanQueryParserSimpleSample.java (working copy) @@ -113,9 +113,9 @@ 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); Index: lucene/contrib/queryparser/src/test/org/apache/lucene/queryParser/spans/TestSpanQueryParser.java =================================================================== --- lucene/contrib/queryparser/src/test/org/apache/lucene/queryParser/spans/TestSpanQueryParser.java (revision 1023895) +++ lucene/contrib/queryparser/src/test/org/apache/lucene/queryParser/spans/TestSpanQueryParser.java (working copy) @@ -117,11 +117,9 @@ 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()); } Index: lucene/contrib/queryparser/src/java/org/apache/lucene/queryParser/standard/processors/StandardQueryNodeProcessorPipeline.java =================================================================== --- lucene/contrib/queryparser/src/java/org/apache/lucene/queryParser/standard/processors/StandardQueryNodeProcessorPipeline.java (revision 1023895) +++ lucene/contrib/queryparser/src/java/org/apache/lucene/queryParser/standard/processors/StandardQueryNodeProcessorPipeline.java (working copy) @@ -48,23 +48,23 @@ 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()); } } Index: lucene/contrib/queryparser/src/java/org/apache/lucene/queryParser/core/processors/QueryNodeProcessorPipeline.java =================================================================== --- lucene/contrib/queryparser/src/java/org/apache/lucene/queryParser/core/processors/QueryNodeProcessorPipeline.java (revision 1023895) +++ lucene/contrib/queryparser/src/java/org/apache/lucene/queryParser/core/processors/QueryNodeProcessorPipeline.java (working copy) @@ -17,7 +17,11 @@ * 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 @@ * 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 @@ * 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 @@ * 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 @@ * 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 @@ } + /** + * @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(); + } + }