Query.java
001 package gate.creole.annic.apache.lucene.search;
002 
003 /**
004  * Copyright 2002-2004 The Apache Software Foundation
005  *
006  * Licensed under the Apache License, Version 2.0 (the "License");
007  * you may not use this file except in compliance with the License.
008  * You may obtain a copy of the License at
009  *
010  *     http://www.apache.org/licenses/LICENSE-2.0
011  *
012  * Unless required by applicable law or agreed to in writing, software
013  * distributed under the License is distributed on an "AS IS" BASIS,
014  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
015  * See the License for the specific language governing permissions and
016  * limitations under the License.
017  */
018 
019 import java.io.IOException;
020 
021 import java.util.HashSet;
022 import java.util.Iterator;
023 
024 import gate.creole.annic.apache.lucene.index.IndexReader;
025 
026 /**
027  * The abstract base class for queries.
028  */
029 @SuppressWarnings({"serial","rawtypes","unchecked"})
030 public abstract class Query implements java.io.Serializable, Cloneable {
031   private float boost = 1.0f;                     // query boost factor
032 
033   /** Sets the boost for this query clause to <code>b</code>.  Documents
034    * matching this clause will (in addition to the normal weightings) have
035    * their score multiplied by <code>b</code>.
036    */
037   public void setBoost(float b) { boost = b; }
038 
039   /** Gets the boost for this clause.  Documents matching
040    * this clause will (in addition to the normal weightings) have their score
041    * multiplied by <code>b</code>.   The boost is 1.0 by default.
042    */
043   public float getBoost() { return boost; }
044 
045   /**
046    * Prints a query to a string, with <code>field</code> as the default field
047    * for terms.
048    */
049   public abstract String toString(String field);
050 
051   /** Prints a query to a string. */
052   @Override
053   public String toString() {
054     return toString("");
055   }
056 
057   /** Expert: Constructs an appropriate Weight implementation for this query.
058    *
059    <p>Only implemented by primitive queries, which re-write to themselves.
060    */
061   protected Weight createWeight(Searcher searcher) {
062     throw new UnsupportedOperationException();
063   }
064 
065   /** Expert: Constructs an initializes a Weight for a top-level query. */
066   public Weight weight(Searcher searcher)
067     throws IOException {
068     Query query = searcher.rewrite(this);
069     Weight weight = query.createWeight(searcher);
070     float sum = weight.sumOfSquaredWeights();
071     float norm = getSimilarity(searcher).queryNorm(sum);
072     weight.normalize(norm);
073     return weight;
074   }
075 
076   /** Expert: called to re-write queries into primitive queries. */
077   public Query rewrite(IndexReader readerthrows IOException {
078     return this;
079   }
080 
081   /** Expert: called when re-writing queries under MultiSearcher.
082    *
083    <p>Only implemented by derived queries, with no
084    {@link #createWeight(Searcher)} implementatation.
085    */
086   public Query combine(Query[] queries) {
087     throw new UnsupportedOperationException();
088   }
089 
090 
091   /** Expert: merges the clauses of a set of BooleanQuery's into a single
092    * BooleanQuery.
093    *
094    *<p>A utility for use by {@link #combine(Query[])} implementations.
095    */
096   public static Query mergeBooleanQueries(Query[] queries) {
097     HashSet allClauses = new HashSet();
098     for (int i = 0; i < queries.length; i++) {
099       BooleanClause[] clauses = ((BooleanQuery)queries[i]).getClauses();
100       for (int j = 0; j < clauses.length; j++) {
101         allClauses.add(clauses[j]);
102       }
103     }
104 
105     BooleanQuery result = new BooleanQuery();
106     Iterator i = allClauses.iterator();
107     while (i.hasNext()) {
108       result.add((BooleanClause)i.next());
109     }
110     return result;
111   }
112 
113   /** Expert: Returns the Similarity implementation to be used for this query.
114    * Subclasses may override this method to specify their own Similarity
115    * implementation, perhaps one that delegates through that of the Searcher.
116    * By default the Searcher's Similarity implementation is returned.*/
117   public Similarity getSimilarity(Searcher searcher) {
118     return searcher.getSimilarity();
119   }
120 
121   /** Returns a clone of this query. */
122   @Override
123   public Object clone() {
124     try {
125       return super.clone();
126     catch (CloneNotSupportedException e) {
127       throw new RuntimeException("Clone not supported: " + e.getMessage());
128     }
129   }
130 }