beagled/Lucene.Net/Search/FieldCacheImpl.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 IndexReader = Lucene.Net.Index.IndexReader;
  18 using Term = Lucene.Net.Index.Term;
  19 using TermDocs = Lucene.Net.Index.TermDocs;
  20 using TermEnum = Lucene.Net.Index.TermEnum;
  21 namespace Lucene.Net.Search
  22 {
  23
  24         /// <summary> Expert: The default cache implementation, storing all values in memory.
  25         /// A WeakHashMap is used for storage.
  26         ///
  27         /// <p>Created: May 19, 2004 4:40:36 PM
  28         ///
  29         /// </summary>
  30         /// <author>   Tim Jones (Nacimiento Software)
  31         /// </author>
  32         /// <since>   lucene 1.4
  33         /// </since>
  34     /// <version>  $Id: FieldCacheImpl.cs,v 1.1 2005/01/17 19:54:30 joeshaw Exp $
  35     /// </version>
  36         class FieldCacheImpl : FieldCache
  37         {
  38
  39                 /// <summary>Expert: Every key in the internal cache is of this type. </summary>
  40                 internal class Entry
  41                 {
  42                         internal System.String field; // which Field
  43                         internal int type; // which SortField type
  44                         internal System.Object custom; // which custom comparator
  45
  46                         /// <summary>Creates one of these objects. </summary>
  47                         internal Entry(System.String field, int type)
  48                         {
  49                 this.field = String.Intern(field);
  50                 this.type = type;
  51                 this.custom = null;
  52             }
  53
  54                         /// <summary>Creates one of these objects for a custom comparator. </summary>
  55                         internal Entry(System.String field, System.Object custom)
  56                         {
  57                 this.field = String.Intern(field);
  58                 this.type = SortField.CUSTOM;
  59                 this.custom = custom;
  60             }
  61
  62                         /// <summary>Two of these are equal iff they reference the same field and type. </summary>
  63                         public  override bool Equals(System.Object o)
  64                         {
  65                                 if (o is Entry)
  66                                 {
  67                                         Entry other = (Entry) o;
  68                                         if ((System.Object) other.field == (System.Object) field && other.type == type)
  69                                         {
  70                                                 if (other.custom == null)
  71                                                 {
  72                                                         if (custom == null)
  73                                                                 return true;
  74                                                 }
  75                                                 else if (other.custom.Equals(custom))
  76                                                 {
  77                                                         return true;
  78                                                 }
  79                                         }
  80                                 }
  81                                 return false;
  82                         }
  83
  84                         /// <summary>Composes a hashcode based on the field and type. </summary>
  85                         public override int GetHashCode()
  86                         {
  87                                 return field.GetHashCode() ^ type ^ (custom == null ? 0 : custom.GetHashCode());
  88                         }
  89                 }
  90
  91
  92                 /// <summary>The internal cache. Maps Entry to array of interpreted term values. *</summary>
  93                 internal System.Collections.IDictionary cache = new System.Collections.Hashtable();
  94
  95                 /// <summary>See if an object is in the cache. </summary>
  96                 internal virtual System.Object Lookup(IndexReader reader, System.String field, int type)
  97                 {
  98                         Entry entry = new Entry(field, type);
  99                         lock (this)
 100                         {
 101                 System.Collections.Hashtable readerCache = (System.Collections.Hashtable) cache[reader];
 102                 if (readerCache == null)
 103                     return null;
 104                 return readerCache[entry];
 105             }
 106                 }
 107
 108                 /// <summary>See if a custom object is in the cache. </summary>
 109                 internal virtual System.Object Lookup(IndexReader reader, System.String field, System.Object comparer)
 110                 {
 111                         Entry entry = new Entry(field, comparer);
 112                         lock (this)
 113                         {
 114                 System.Collections.Hashtable readerCache = (System.Collections.Hashtable) cache[reader];
 115                 if (readerCache == null)
 116                     return null;
 117                 return readerCache[entry];
 118             }
 119                 }
 120
 121                 /// <summary>Put an object into the cache. </summary>
 122                 internal virtual System.Object Store(IndexReader reader, System.String field, int type, System.Object value_Renamed)
 123                 {
 124                         Entry entry = new Entry(field, type);
 125                         lock (this)
 126                         {
 127                 System.Collections.Hashtable readerCache = (System.Collections.Hashtable) cache[reader];
 128                 if (readerCache == null)
 129                 {
 130                     readerCache = new System.Collections.Hashtable();
 131                     cache[reader] = readerCache;
 132                 }
 133                 System.Object tempObject;
 134                 tempObject = readerCache[entry];
 135                 readerCache[entry] = value_Renamed;
 136                 return tempObject;
 137             }
 138                 }
 139
 140                 /// <summary>Put a custom object into the cache. </summary>
 141                 internal virtual System.Object Store(IndexReader reader, System.String field, System.Object comparer, System.Object value_Renamed)
 142                 {
 143                         Entry entry = new Entry(field, comparer);
 144                         lock (this)
 145                         {
 146                 System.Collections.Hashtable readerCache = (System.Collections.Hashtable) cache[reader];
 147                 if (readerCache == null)
 148                 {
 149                     readerCache = new System.Collections.Hashtable();
 150                     cache[reader] = readerCache;
 151                 }
 152                 System.Object tempObject;
 153                 tempObject = readerCache[entry];
 154                 readerCache[entry] = value_Renamed;
 155                 return tempObject;
 156             }
 157                 }
 158
 159                 // inherit javadocs
 160                 public virtual int[] GetInts(IndexReader reader, System.String field)
 161                 {
 162                         field = String.Intern(field);
 163                         System.Object ret = Lookup(reader, field, SortField.INT);
 164                         if (ret == null)
 165                         {
 166                                 int[] retArray = new int[reader.MaxDoc()];
 167                                 if (retArray.Length > 0)
 168                                 {
 169                                         TermDocs termDocs = reader.TermDocs();
 170                                         TermEnum termEnum = reader.Terms(new Term(field, ""));
 171                                         try
 172                                         {
 173                                                 if (termEnum.Term() == null)
 174                                                 {
 175                                                         throw new System.SystemException("no terms in Field " + field);
 176                                                 }
 177                                                 do
 178                                                 {
 179                                                         Term term = termEnum.Term();
 180                                                         if ((System.Object) term.Field() != (System.Object) field)
 181                                                                 break;
 182                                                         int termval = System.Int32.Parse(term.Text());
 183                                                         termDocs.Seek(termEnum);
 184                                                         while (termDocs.Next())
 185                                                         {
 186                                                                 retArray[termDocs.Doc()] = termval;
 187                                                         }
 188                                                 }
 189                                                 while (termEnum.Next());
 190                                         }
 191                                         finally
 192                                         {
 193                                                 termDocs.Close();
 194                                                 termEnum.Close();
 195                                         }
 196                                 }
 197                                 Store(reader, field, SortField.INT, retArray);
 198                                 return retArray;
 199                         }
 200                         return (int[]) ret;
 201                 }
 202
 203                 // inherit javadocs
 204                 public virtual float[] GetFloats(IndexReader reader, System.String field)
 205                 {
 206                         field = String.Intern(field);
 207                         System.Object ret = Lookup(reader, field, SortField.FLOAT);
 208                         if (ret == null)
 209                         {
 210                                 float[] retArray = new float[reader.MaxDoc()];
 211                                 if (retArray.Length > 0)
 212                                 {
 213                                         TermDocs termDocs = reader.TermDocs();
 214                                         TermEnum termEnum = reader.Terms(new Term(field, ""));
 215                     try
 216                     {
 217                         if (termEnum.Term() == null)
 218                         {
 219                             throw new System.SystemException("no terms in Field " + field);
 220                         }
 221                         do
 222                         {
 223                             Term term = termEnum.Term();
 224                             if ((System.Object) term.Field() != (System.Object) field)
 225                                 break;
 226                             float termval;
 227                             try
 228                             {
 229                                 termval = SupportClass.Single.Parse(term.Text());
 230                             }
 231                             catch (Exception e)
 232                             {
 233                                 termval = 0;
 234                             }
 235                             termDocs.Seek(termEnum);
 236                             while (termDocs.Next())
 237                             {
 238                                 retArray[termDocs.Doc()] = termval;
 239                             }
 240                         }
 241                         while (termEnum.Next());
 242                     }
 243                     finally
 244                     {
 245                         termDocs.Close();
 246                         termEnum.Close();
 247                     }
 248                                 }
 249                                 Store(reader, field, SortField.FLOAT, retArray);
 250                                 return retArray;
 251                         }
 252                         return (float[]) ret;
 253                 }
 254
 255                 // inherit javadocs
 256                 public virtual System.String[] GetStrings(IndexReader reader, System.String field)
 257                 {
 258                         field = String.Intern(field);
 259                         System.Object ret = Lookup(reader, field, SortField.STRING);
 260                         if (ret == null)
 261                         {
 262                                 System.String[] retArray = new System.String[reader.MaxDoc()];
 263                                 if (retArray.Length > 0)
 264                                 {
 265                                         TermDocs termDocs = reader.TermDocs();
 266                                         TermEnum termEnum = reader.Terms(new Term(field, ""));
 267                                         try
 268                                         {
 269                                                 if (termEnum.Term() == null)
 270                                                 {
 271                                                         throw new System.SystemException("no terms in Field " + field);
 272                                                 }
 273                                                 do
 274                                                 {
 275                                                         Term term = termEnum.Term();
 276                                                         if ((System.Object) term.Field() != (System.Object) field)
 277                                                                 break;
 278                                                         System.String termval = term.Text();
 279                                                         termDocs.Seek(termEnum);
 280                                                         while (termDocs.Next())
 281                                                         {
 282                                                                 retArray[termDocs.Doc()] = termval;
 283                                                         }
 284                                                 }
 285                                                 while (termEnum.Next());
 286                                         }
 287                                         finally
 288                                         {
 289                                                 termDocs.Close();
 290                                                 termEnum.Close();
 291                                         }
 292                                 }
 293                                 Store(reader, field, SortField.STRING, retArray);
 294                                 return retArray;
 295                         }
 296                         return (System.String[]) ret;
 297                 }
 298
 299                 // inherit javadocs
 300                 public virtual StringIndex GetStringIndex(IndexReader reader, System.String field)
 301                 {
 302                         field = String.Intern(field);
 303                         System.Object ret = Lookup(reader, field, Lucene.Net.Search.FieldCache_Fields.STRING_INDEX);
 304                         if (ret == null)
 305                         {
 306                                 int[] retArray = new int[reader.MaxDoc()];
 307                                 System.String[] mterms = new System.String[reader.MaxDoc() + 1];
 308                                 if (retArray.Length > 0)
 309                                 {
 310                                         TermDocs termDocs = reader.TermDocs();
 311                                         TermEnum termEnum = reader.Terms(new Term(field, ""));
 312                                         int t = 0; // current term number
 313
 314                                         // an entry for documents that have no terms in this Field
 315                                         // should a document with no terms be at top or bottom?
 316                                         // this puts them at the top - if it is changed, FieldDocSortedHitQueue
 317                                         // needs to change as well.
 318                                         mterms[t++] = null;
 319
 320                                         try
 321                                         {
 322                                                 if (termEnum.Term() == null)
 323                                                 {
 324                                                         throw new System.SystemException("no terms in Field " + field);
 325                                                 }
 326                                                 do
 327                                                 {
 328                                                         Term term = termEnum.Term();
 329                                                         if ((System.Object) term.Field() != (System.Object) field)
 330                                                                 break;
 331
 332                                                         // store term text
 333                                                         // we expect that there is at most one term per document
 334                                                         if (t >= mterms.Length)
 335                                                                 throw new System.SystemException("there are more terms than documents in Field \"" + field + "\"");
 336                                                         mterms[t] = term.Text();
 337
 338                                                         termDocs.Seek(termEnum);
 339                                                         while (termDocs.Next())
 340                                                         {
 341                                                                 retArray[termDocs.Doc()] = t;
 342                                                         }
 343
 344                                                         t++;
 345                                                 }
 346                                                 while (termEnum.Next());
 347                                         }
 348                                         finally
 349                                         {
 350                                                 termDocs.Close();
 351                                                 termEnum.Close();
 352                                         }
 353
 354                                         if (t == 0)
 355                                         {
 356                                                 // if there are no terms, make the term array
 357                                                 // have a single null entry
 358                                                 mterms = new System.String[1];
 359                                         }
 360                                         else if (t < mterms.Length)
 361                                         {
 362                                                 // if there are less terms than documents,
 363                                                 // trim off the dead array space
 364                                                 System.String[] terms = new System.String[t];
 365                                                 Array.Copy(mterms, 0, terms, 0, t);
 366                                                 mterms = terms;
 367                                         }
 368                                 }
 369                                 StringIndex value_Renamed = new StringIndex(retArray, mterms);
 370                                 Store(reader, field, Lucene.Net.Search.FieldCache_Fields.STRING_INDEX, value_Renamed);
 371                                 return value_Renamed;
 372                         }
 373                         return (StringIndex) ret;
 374                 }
 375
 376                 /// <summary>The pattern used to detect integer values in a Field </summary>
 377                 /// <summary>removed for java 1.3 compatibility
 378                 /// protected static final Pattern pIntegers = Pattern.compile ("[0-9\\-]+");
 379                 ///
 380                 /// </summary>
 381
 382                 /// <summary>The pattern used to detect float values in a Field </summary>
 383                 /// <summary> removed for java 1.3 compatibility
 384                 /// protected static final Object pFloats = Pattern.compile ("[0-9+\\-\\.eEfFdD]+");
 385                 /// </summary>
 386
 387                 // inherit javadocs
 388                 public virtual System.Object GetAuto(IndexReader reader, System.String field)
 389                 {
 390                         field = String.Intern(field);
 391                         System.Object ret = Lookup(reader, field, SortField.AUTO);
 392                         if (ret == null)
 393                         {
 394                                 TermEnum enumerator = reader.Terms(new Term(field, ""));
 395                                 try
 396                                 {
 397                                         Term term = enumerator.Term();
 398                                         if (term == null)
 399                                         {
 400                                                 throw new System.SystemException("no terms in Field " + field + " - cannot determine sort type");
 401                                         }
 402                                         if ((System.Object) term.Field() == (System.Object) field)
 403                                         {
 404                                                 System.String termtext = term.Text().Trim();
 405
 406                                                 /// <summary> Java 1.4 level code:
 407                                                 /// if (pIntegers.matcher(termtext).matches())
 408                                                 /// return IntegerSortedHitQueue.comparator (reader, enumerator, Field);
 409                                                 /// else if (pFloats.matcher(termtext).matches())
 410                                                 /// return FloatSortedHitQueue.comparator (reader, enumerator, Field);
 411                                                 /// </summary>
 412
 413                                                 // Java 1.3 level code:
 414                                                 try
 415                                                 {
 416                                                         System.Int32.Parse(termtext);
 417                                                         ret = GetInts(reader, field);
 418                                                 }
 419                                                 catch (System.FormatException nfe1)
 420                                                 {
 421                                                         try
 422                                                         {
 423                                                                 System.Single.Parse(termtext);
 424                                                                 ret = GetFloats(reader, field);
 425                                                         }
 426                                                         catch (System.FormatException nfe2)
 427                                                         {
 428                                                                 ret = GetStringIndex(reader, field);
 429                                                         }
 430                                                 }
 431                                                 if (ret != null)
 432                                                 {
 433                                                         Store(reader, field, SortField.AUTO, ret);
 434                                                 }
 435                                         }
 436                                         else
 437                                         {
 438                                                 throw new System.SystemException("Field \"" + field + "\" does not appear to be indexed");
 439                                         }
 440                                 }
 441                                 finally
 442                                 {
 443                                         enumerator.Close();
 444                                 }
 445                         }
 446                         return ret;
 447                 }
 448
 449                 // inherit javadocs
 450                 public virtual System.IComparable[] GetCustom(IndexReader reader, System.String field, SortComparator comparator)
 451                 {
 452                         field = String.Intern(field);
 453                         System.Object ret = Lookup(reader, field, comparator);
 454                         if (ret == null)
 455                         {
 456                                 System.IComparable[] retArray = new System.IComparable[reader.MaxDoc()];
 457                                 if (retArray.Length > 0)
 458                                 {
 459                                         TermDocs termDocs = reader.TermDocs();
 460                                         TermEnum termEnum = reader.Terms(new Term(field, ""));
 461                                         try
 462                                         {
 463                                                 if (termEnum.Term() == null)
 464                                                 {
 465                                                         throw new System.SystemException("no terms in Field " + field);
 466                                                 }
 467                                                 do
 468                                                 {
 469                                                         Term term = termEnum.Term();
 470                                                         if ((System.Object) term.Field() != (System.Object) field)
 471                                                                 break;
 472                                                         System.IComparable termval = comparator.GetComparable(term.Text());
 473                                                         termDocs.Seek(termEnum);
 474                                                         while (termDocs.Next())
 475                                                         {
 476                                                                 retArray[termDocs.Doc()] = termval;
 477                                                         }
 478                                                 }
 479                                                 while (termEnum.Next());
 480                                         }
 481                                         finally
 482                                         {
 483                                                 termDocs.Close();
 484                                                 termEnum.Close();
 485                                         }
 486                                 }
 487                                 Store(reader, field, SortField.CUSTOM, retArray);
 488                                 return retArray;
 489                         }
 490                         return (System.IComparable[]) ret;
 491                 }
 492         }
 493 }