beagled/Lucene.Net/Search/FilteredTermEnum.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 Term = Lucene.Net.Index.Term;
  18 using TermEnum = Lucene.Net.Index.TermEnum;
  19 namespace Lucene.Net.Search
  20 {
  21
  22         /// <summary>Abstract class for enumerating a subset of all terms.
  23         /// <p>Term enumerations are always ordered by Term.compareTo().  Each term in
  24         /// the enumeration is greater than all that precede it.
  25         /// </summary>
  26         public abstract class FilteredTermEnum:TermEnum
  27         {
  28                 private Term currentTerm = null;
  29                 private TermEnum actualEnum = null;
  30
  31                 public FilteredTermEnum()
  32                 {
  33                 }
  34
  35                 /// <summary>Equality compare on the term </summary>
  36                 protected internal abstract bool TermCompare(Term term);
  37
  38                 /// <summary>Equality measure on the term </summary>
  39                 public abstract float Difference();
  40
  41                 /// <summary>Indiciates the end of the enumeration has been reached </summary>
  42                 public abstract bool EndEnum();
  43
  44                 protected internal virtual void  SetEnum(TermEnum actualEnum)
  45                 {
  46                         this.actualEnum = actualEnum;
  47                         // Find the first term that matches
  48                         Term term = actualEnum.Term();
  49                         if (term != null && TermCompare(term))
  50                                 currentTerm = term;
  51                         else
  52                                 Next();
  53                 }
  54
  55         /// <summary> Returns the docFreq of the current Term in the enumeration.
  56         /// Returns -1 if no Term matches or all terms have been enumerated.
  57         /// </summary>
  58         public override int DocFreq()
  59                 {
  60                         if (actualEnum == null)
  61                                 return - 1;
  62                         return actualEnum.DocFreq();
  63                 }
  64
  65                 /// <summary>Increments the enumeration to the next element.  True if one exists. </summary>
  66                 public override bool Next()
  67                 {
  68                         if (actualEnum == null)
  69                                 return false; // the actual enumerator is not initialized!
  70                         currentTerm = null;
  71                         while (currentTerm == null)
  72                         {
  73                                 if (EndEnum())
  74                                         return false;
  75                                 if (actualEnum.Next())
  76                                 {
  77                                         Term term = actualEnum.Term();
  78                                         if (TermCompare(term))
  79                                         {
  80                                                 currentTerm = term;
  81                                                 return true;
  82                                         }
  83                                 }
  84                                 else
  85                                         return false;
  86                         }
  87                         currentTerm = null;
  88                         return false;
  89                 }
  90
  91         /// <summary>Returns the current Term in the enumeration.
  92         /// Returns null if no Term matches or all terms have been enumerated.
  93         /// </summary>
  94         public override Term Term()
  95                 {
  96                         return currentTerm;
  97                 }
  98
  99                 /// <summary>Closes the enumeration to further activity, freeing resources.  </summary>
 100                 public override void  Close()
 101                 {
 102                         actualEnum.Close();
 103                         currentTerm = null;
 104                         actualEnum = null;
 105                 }
 106         }
 107 }