beagled/Lucene.Net/Search/MultiSearcher.cs

   1 /*
   2  * Copyright 2004 The Apache Software Foundation
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 using System;
  17 using Document = Lucene.Net.Documents.Document;
  18 using Term = Lucene.Net.Index.Term;
  19 namespace Lucene.Net.Search
  20 {
  21
  22         /// <summary>Implements search over a set of <code>Searchables</code>.
  23         ///
  24         /// <p>Applications usually need only call the inherited {@link #Search(Query)}
  25         /// or {@link #Search(Query,Filter)} methods.
  26         /// </summary>
  27         public class MultiSearcher : Searcher
  28         {
  29                 private class AnonymousClassHitCollector : HitCollector
  30                 {
  31                         public AnonymousClassHitCollector(Lucene.Net.Search.HitCollector results, int start, MultiSearcher enclosingInstance)
  32                         {
  33                                 InitBlock(results, start, enclosingInstance);
  34                         }
  35                         private void  InitBlock(Lucene.Net.Search.HitCollector results, int start, MultiSearcher enclosingInstance)
  36                         {
  37                                 this.results = results;
  38                                 this.start = start;
  39                                 this.enclosingInstance = enclosingInstance;
  40                         }
  41                         private Lucene.Net.Search.HitCollector results;
  42                         private int start;
  43                         private MultiSearcher enclosingInstance;
  44                         public MultiSearcher Enclosing_Instance
  45                         {
  46                                 get
  47                                 {
  48                                         return enclosingInstance;
  49                                 }
  50
  51                         }
  52                         public override void  Collect(int doc, float score)
  53                         {
  54                                 results.Collect(doc + start, score);
  55                         }
  56                 }
  57                 private Lucene.Net.Search.Searchable[] searchables;
  58                 private int[] starts;
  59                 private int maxDoc = 0;
  60
  61                 /// <summary>Creates a searcher which searches <i>searchables</i>. </summary>
  62                 public MultiSearcher(Lucene.Net.Search.Searchable[] searchables)
  63                 {
  64                         this.searchables = searchables;
  65
  66                         starts = new int[searchables.Length + 1]; // build starts array
  67                         for (int i = 0; i < searchables.Length; i++)
  68                         {
  69                                 starts[i] = maxDoc;
  70                                 maxDoc += searchables[i].MaxDoc(); // compute maxDocs
  71                         }
  72                         starts[searchables.Length] = maxDoc;
  73                 }
  74
  75                 protected internal virtual int[] GetStarts()
  76                 {
  77                         return starts;
  78                 }
  79
  80                 // inherit javadoc
  81                 public override void  Close()
  82                 {
  83                         for (int i = 0; i < searchables.Length; i++)
  84                                 searchables[i].Close();
  85                 }
  86
  87                 public override int DocFreq(Term term)
  88                 {
  89                         int docFreq = 0;
  90                         for (int i = 0; i < searchables.Length; i++)
  91                                 docFreq += searchables[i].DocFreq(term);
  92                         return docFreq;
  93                 }
  94
  95                 // inherit javadoc
  96                 public override Document Doc(int n)
  97                 {
  98                         int i = SubSearcher(n); // find searcher index
  99                         return searchables[i].Doc(n - starts[i]); // dispatch to searcher
 100                 }
 101
 102                 /// <summary>Call {@link #subSearcher} instead.</summary>
 103                 /// <deprecated>
 104                 /// </deprecated>
 105                 public virtual int SearcherIndex(int n)
 106                 {
 107                         return SubSearcher(n);
 108                 }
 109
 110                 /// <summary>Returns index of the searcher for document <code>n</code> in the array
 111                 /// used to construct this searcher.
 112                 /// </summary>
 113                 public virtual int SubSearcher(int n)
 114                 {
 115                         // find searcher for doc n:
 116                         // replace w/ call to Arrays.binarySearch in Java 1.2
 117                         int lo = 0; // search starts array
 118                         int hi = searchables.Length - 1; // for first element less
 119                         // than n, return its index
 120                         while (hi >= lo)
 121                         {
 122                                 int mid = (lo + hi) >> 1;
 123                                 int midValue = starts[mid];
 124                                 if (n < midValue)
 125                                         hi = mid - 1;
 126                                 else if (n > midValue)
 127                                         lo = mid + 1;
 128                                 else
 129                                 {
 130                                         // found a match
 131                                         while (mid + 1 < searchables.Length && starts[mid + 1] == midValue)
 132                                         {
 133                                                 mid++; // scan to last match
 134                                         }
 135                                         return mid;
 136                                 }
 137                         }
 138                         return hi;
 139                 }
 140
 141                 /// <summary>Returns the document number of document <code>n</code> within its
 142                 /// sub-index.
 143                 /// </summary>
 144                 public virtual int SubDoc(int n)
 145                 {
 146                         return n - starts[SubSearcher(n)];
 147                 }
 148
 149                 public override int MaxDoc()
 150                 {
 151                         return maxDoc;
 152                 }
 153
 154                 public override TopDocs Search(Query query, Filter filter, int nDocs)
 155                 {
 156                         HitQueue hq = new HitQueue(nDocs);
 157                         int totalHits = 0;
 158
 159                         for (int i = 0; i < searchables.Length; i++)
 160                         {
 161                                 // search each searcher
 162                                 TopDocs docs = searchables[i].Search(query, filter, nDocs);
 163                                 totalHits += docs.totalHits; // update totalHits
 164                                 ScoreDoc[] scoreDocs = docs.scoreDocs;
 165                                 for (int j = 0; j < scoreDocs.Length; j++)
 166                                 {
 167                                         // merge scoreDocs into hq
 168                                         ScoreDoc scoreDoc = scoreDocs[j];
 169                                         scoreDoc.doc += starts[i]; // convert doc
 170                                         if (!hq.Insert(scoreDoc))
 171                                                 break; // no more scores > minScore
 172                                 }
 173                         }
 174
 175                         ScoreDoc[] scoreDocs2 = new ScoreDoc[hq.Size()];
 176                         for (int i = hq.Size() - 1; i >= 0; i--)
 177                         // put docs in array
 178                                 scoreDocs2[i] = (ScoreDoc) hq.Pop();
 179
 180                         return new TopDocs(totalHits, scoreDocs2);
 181                 }
 182
 183
 184                 public override TopFieldDocs Search(Query query, Filter filter, int n, Sort sort)
 185                 {
 186                         FieldDocSortedHitQueue hq = null;
 187                         int totalHits = 0;
 188
 189                         for (int i = 0; i < searchables.Length; i++)
 190                         {
 191                                 // search each searcher
 192                                 TopFieldDocs docs = searchables[i].Search(query, filter, n, sort);
 193                                 if (hq == null)
 194                                         hq = new FieldDocSortedHitQueue(docs.fields, n);
 195                                 totalHits += docs.totalHits; // update totalHits
 196                                 ScoreDoc[] scoreDocs = docs.scoreDocs;
 197                                 for (int j = 0; j < scoreDocs.Length; j++)
 198                                 {
 199                                         // merge scoreDocs into hq
 200                                         ScoreDoc scoreDoc = scoreDocs[j];
 201                                         scoreDoc.doc += starts[i]; // convert doc
 202                                         if (!hq.Insert(scoreDoc))
 203                                                 break; // no more scores > minScore
 204                                 }
 205                         }
 206
 207                         ScoreDoc[] scoreDocs2 = new ScoreDoc[hq.Size()];
 208                         for (int i = hq.Size() - 1; i >= 0; i--)
 209                         // put docs in array
 210                                 scoreDocs2[i] = (ScoreDoc) hq.Pop();
 211
 212                         return new TopFieldDocs(totalHits, scoreDocs2, hq.GetFields());
 213                 }
 214
 215
 216                 // inherit javadoc
 217                 public override void  Search(Query query, Filter filter, HitCollector results)
 218                 {
 219                         for (int i = 0; i < searchables.Length; i++)
 220                         {
 221
 222                                 int start = starts[i];
 223
 224                                 searchables[i].Search(query, filter, new AnonymousClassHitCollector(results, start, this));
 225                         }
 226                 }
 227
 228                 public override Query Rewrite(Query original)
 229                 {
 230                         Query[] queries = new Query[searchables.Length];
 231                         for (int i = 0; i < searchables.Length; i++)
 232                         {
 233                                 queries[i] = searchables[i].Rewrite(original);
 234                         }
 235                         return original.Combine(queries);
 236                 }
 237
 238                 public override Explanation Explain(Query query, int doc)
 239                 {
 240                         int i = SubSearcher(doc); // find searcher index
 241                         return searchables[i].Explain(query, doc - starts[i]); // dispatch to searcher
 242                 }
 243         }
 244 }