beagled/Lucene.Net/Search/Hits.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 namespace Lucene.Net.Search
  19 {
  20
  21         /// <summary>A ranked list of documents, used to hold search results. </summary>
  22         public sealed class Hits
  23         {
  24                 private Query query;
  25                 private Searcher searcher;
  26                 private Filter filter = null;
  27                 private Sort sort = null;
  28
  29                 private int length; // the total number of hits
  30                 private System.Collections.ArrayList hitDocs = System.Collections.ArrayList.Synchronized(new System.Collections.ArrayList(10)); // cache of hits retrieved
  31
  32                 private HitDoc first; // head of LRU cache
  33                 private HitDoc last; // tail of LRU cache
  34                 private int numDocs = 0; // number cached
  35                 private int maxDocs = 200; // max to cache
  36
  37                 internal Hits(Searcher s, Query q, Filter f)
  38                 {
  39                         query = q;
  40                         searcher = s;
  41                         filter = f;
  42                         GetMoreDocs(50); // retrieve 100 initially
  43                 }
  44
  45                 internal Hits(Searcher s, Query q, Filter f, Sort o)
  46                 {
  47                         query = q;
  48                         searcher = s;
  49                         filter = f;
  50                         sort = o;
  51                         GetMoreDocs(50); // retrieve 100 initially
  52                 }
  53
  54                 /// <summary> Tries to add new documents to hitDocs.
  55                 /// Ensures that the hit numbered <code>min</code> has been retrieved.
  56                 /// </summary>
  57                 private void  GetMoreDocs(int min)
  58                 {
  59                         if (hitDocs.Count > min)
  60                         {
  61                                 min = hitDocs.Count;
  62                         }
  63
  64                         int n = min * 2; // double # retrieved
  65                         TopDocs topDocs = (sort == null) ? searcher.Search(query, filter, n) : searcher.Search(query, filter, n, sort);
  66                         length = topDocs.totalHits;
  67                         ScoreDoc[] scoreDocs = topDocs.scoreDocs;
  68
  69                         float scoreNorm = 1.0f;
  70                         if (length > 0 && scoreDocs[0].score > 1.0f)
  71                         {
  72                                 scoreNorm = 1.0f / scoreDocs[0].score;
  73                         }
  74
  75                         int end = scoreDocs.Length < length?scoreDocs.Length:length;
  76                         for (int i = hitDocs.Count; i < end; i++)
  77                         {
  78                                 hitDocs.Add(new HitDoc(scoreDocs[i].score * scoreNorm, scoreDocs[i].doc));
  79                         }
  80                 }
  81
  82                 /// <summary>Returns the total number of hits available in this set. </summary>
  83                 public int Length()
  84                 {
  85                         return length;
  86                 }
  87
  88                 /// <summary>Returns the stored fields of the n<sup>th</sup> document in this set.
  89                 /// <p>Documents are cached, so that repeated requests for the same element may
  90                 /// return the same Document object.
  91                 /// </summary>
  92                 public Document Doc(int n)
  93                 {
  94                         HitDoc hitDoc = HitDoc(n);
  95
  96                         // Update LRU cache of documents
  97                         Remove(hitDoc); // remove from list, if there
  98                         AddToFront(hitDoc); // add to front of list
  99                         if (numDocs > maxDocs)
 100                         {
 101                                 // if cache is full
 102                                 HitDoc oldLast = last;
 103                                 Remove(last); // flush last
 104                                 oldLast.doc = null; // let doc get gc'd
 105                         }
 106
 107                         if (hitDoc.doc == null)
 108                         {
 109                                 hitDoc.doc = searcher.Doc(hitDoc.id); // cache miss: read document
 110                         }
 111
 112                         return hitDoc.doc;
 113                 }
 114
 115                 /// <summary>Returns the score for the nth document in this set. </summary>
 116                 public float Score(int n)
 117                 {
 118                         return HitDoc(n).score;
 119                 }
 120
 121                 /// <summary>Returns the id for the nth document in this set. </summary>
 122                 public int Id(int n)
 123                 {
 124                         return HitDoc(n).id;
 125                 }
 126
 127
 128                 private HitDoc HitDoc(int n)
 129                 {
 130                         if (n >= length)
 131                         {
 132                                 throw new System.IndexOutOfRangeException("Not a valid hit number: " + n);
 133                         }
 134
 135                         if (n >= hitDocs.Count)
 136                         {
 137                                 GetMoreDocs(n);
 138                         }
 139
 140                         return (HitDoc) hitDocs[n];
 141                 }
 142
 143                 private void  AddToFront(HitDoc hitDoc)
 144                 {
 145                         // insert at front of cache
 146                         if (first == null)
 147                         {
 148                                 last = hitDoc;
 149                         }
 150                         else
 151                         {
 152                                 first.prev = hitDoc;
 153                         }
 154
 155                         hitDoc.next = first;
 156                         first = hitDoc;
 157                         hitDoc.prev = null;
 158
 159                         numDocs++;
 160                 }
 161
 162                 private void  Remove(HitDoc hitDoc)
 163                 {
 164                         // remove from cache
 165                         if (hitDoc.doc == null)
 166                         {
 167                                 // it's not in the list
 168                                 return ; // abort
 169                         }
 170
 171                         if (hitDoc.next == null)
 172                         {
 173                                 last = hitDoc.prev;
 174                         }
 175                         else
 176                         {
 177                                 hitDoc.next.prev = hitDoc.prev;
 178                         }
 179
 180                         if (hitDoc.prev == null)
 181                         {
 182                                 first = hitDoc.next;
 183                         }
 184                         else
 185                         {
 186                                 hitDoc.prev.next = hitDoc.next;
 187                         }
 188
 189                         numDocs--;
 190                 }
 191         }
 192
 193         sealed class HitDoc
 194         {
 195                 internal float score;
 196                 internal int id;
 197                 internal Document doc = null;
 198
 199                 internal HitDoc next; // in doubly-linked cache
 200                 internal HitDoc prev; // in doubly-linked cache
 201
 202                 internal HitDoc(float s, int i)
 203                 {
 204                         score = s;
 205                         id = i;
 206                 }
 207         }
 208 }