beagled/Lucene.Net/Index/FilterIndexReader.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 Field = Lucene.Net.Documents.Field;
  19 namespace Lucene.Net.Index
  20 {
  21
  22         /// <summary>A <code>FilterIndexReader</code> contains another IndexReader, which it
  23         /// uses as its basic source of data, possibly transforming the data along the
  24         /// way or providing additional functionality. The class
  25         /// <code>FilterIndexReader</code> itself simply implements all abstract methods
  26         /// of <code>IndexReader</code> with versions that pass all requests to the
  27         /// contained index reader. Subclasses of <code>FilterIndexReader</code> may
  28         /// further override some of these methods and may also provide additional
  29         /// methods and fields.
  30         /// </summary>
  31         public class FilterIndexReader : IndexReader
  32         {
  33
  34                 /// <summary>Base class for filtering {@link TermDocs} implementations. </summary>
  35                 public class FilterTermDocs : TermDocs
  36                 {
  37                         protected internal TermDocs in_Renamed;
  38
  39                         public FilterTermDocs(TermDocs in_Renamed)
  40                         {
  41                                 this.in_Renamed = in_Renamed;
  42                         }
  43
  44                         public virtual void  Seek(Term term)
  45                         {
  46                                 in_Renamed.Seek(term);
  47                         }
  48                         public virtual void  Seek(TermEnum termEnum)
  49                         {
  50                                 in_Renamed.Seek(termEnum);
  51                         }
  52                         public virtual int Doc()
  53                         {
  54                                 return in_Renamed.Doc();
  55                         }
  56                         public virtual int Freq()
  57                         {
  58                                 return in_Renamed.Freq();
  59                         }
  60                         public virtual bool Next()
  61                         {
  62                                 return in_Renamed.Next();
  63                         }
  64                         public virtual int Read(int[] docs, int[] freqs)
  65                         {
  66                                 return in_Renamed.Read(docs, freqs);
  67                         }
  68                         public virtual bool SkipTo(int i)
  69                         {
  70                                 return in_Renamed.SkipTo(i);
  71                         }
  72                         public virtual void  Close()
  73                         {
  74                                 in_Renamed.Close();
  75                         }
  76                 }
  77
  78                 /// <summary>Base class for filtering {@link TermPositions} implementations. </summary>
  79                 public class FilterTermPositions:FilterTermDocs, TermPositions
  80                 {
  81
  82                         public FilterTermPositions(TermPositions in_Renamed) : base(in_Renamed)
  83                         {
  84                         }
  85
  86                         public virtual int NextPosition()
  87                         {
  88                                 return ((TermPositions) this.in_Renamed).NextPosition();
  89                         }
  90                 }
  91
  92                 /// <summary>Base class for filtering {@link TermEnum} implementations. </summary>
  93                 public class FilterTermEnum : TermEnum
  94                 {
  95                         protected internal TermEnum in_Renamed;
  96
  97                         public FilterTermEnum(TermEnum in_Renamed)
  98                         {
  99                                 this.in_Renamed = in_Renamed;
 100                         }
 101
 102                         public override bool Next()
 103                         {
 104                                 return in_Renamed.Next();
 105                         }
 106                         public override Term Term()
 107                         {
 108                                 return in_Renamed.Term();
 109                         }
 110                         public override int DocFreq()
 111                         {
 112                                 return in_Renamed.DocFreq();
 113                         }
 114                         public override void  Close()
 115                         {
 116                                 in_Renamed.Close();
 117                         }
 118                 }
 119
 120                 protected internal IndexReader in_Renamed;
 121
 122                 /// <summary> <p>Construct a FilterIndexReader based on the specified base reader.
 123                 /// Directory locking for delete, undeleteAll, and setNorm operations is
 124                 /// left to the base reader.</p>
 125                 /// <p>Note that base reader is closed if this FilterIndexReader is closed.</p>
 126                 /// </summary>
 127                 /// <param name="in">specified base reader.
 128                 /// </param>
 129                 public FilterIndexReader(IndexReader in_Renamed):base(in_Renamed.Directory())
 130                 {
 131                         this.in_Renamed = in_Renamed;
 132                 }
 133
 134                 public override TermFreqVector[] GetTermFreqVectors(int docNumber)
 135                 {
 136                         return in_Renamed.GetTermFreqVectors(docNumber);
 137                 }
 138
 139                 public override TermFreqVector GetTermFreqVector(int docNumber, System.String field)
 140                 {
 141                         return in_Renamed.GetTermFreqVector(docNumber, field);
 142                 }
 143
 144                 public override int NumDocs()
 145                 {
 146                         return in_Renamed.NumDocs();
 147                 }
 148                 public override int MaxDoc()
 149                 {
 150                         return in_Renamed.MaxDoc();
 151                 }
 152
 153                 public override Document Document(int n)
 154                 {
 155                         return in_Renamed.Document(n);
 156                 }
 157
 158                 public override bool IsDeleted(int n)
 159                 {
 160                         return in_Renamed.IsDeleted(n);
 161                 }
 162                 public override bool HasDeletions()
 163                 {
 164                         return in_Renamed.HasDeletions();
 165                 }
 166                 protected internal override void  DoUndeleteAll()
 167                 {
 168                         in_Renamed.UndeleteAll();
 169                 }
 170
 171                 public override byte[] Norms(System.String f)
 172                 {
 173                         return in_Renamed.Norms(f);
 174                 }
 175                 public override void  Norms(System.String f, byte[] bytes, int offset)
 176                 {
 177                         in_Renamed.Norms(f, bytes, offset);
 178                 }
 179                 protected internal override void  DoSetNorm(int d, System.String f, byte b)
 180                 {
 181                         in_Renamed.SetNorm(d, f, b);
 182                 }
 183
 184                 public override TermEnum Terms()
 185                 {
 186                         return in_Renamed.Terms();
 187                 }
 188                 public override TermEnum Terms(Term t)
 189                 {
 190                         return in_Renamed.Terms(t);
 191                 }
 192
 193                 public override int DocFreq(Term t)
 194                 {
 195                         return in_Renamed.DocFreq(t);
 196                 }
 197
 198                 public override TermDocs TermDocs()
 199                 {
 200                         return in_Renamed.TermDocs();
 201                 }
 202
 203                 public override TermPositions TermPositions()
 204                 {
 205                         return in_Renamed.TermPositions();
 206                 }
 207
 208                 protected internal override void  DoDelete(int n)
 209                 {
 210                         in_Renamed.Delete(n);
 211                 }
 212                 protected internal override void  DoCommit()
 213                 {
 214                         in_Renamed.Commit();
 215                 }
 216                 protected internal override void  DoClose()
 217                 {
 218                         in_Renamed.Close();
 219                 }
 220
 221                 public override System.Collections.ICollection GetFieldNames()
 222                 {
 223                         return in_Renamed.GetFieldNames();
 224                 }
 225
 226         public override System.Collections.ICollection GetFieldNames(bool indexed)
 227         {
 228             return in_Renamed.GetFieldNames(indexed);
 229         }
 230
 231         public override System.Collections.ICollection GetIndexedFieldNames(Field.TermVector tvSpec)
 232         {
 233             return in_Renamed.GetIndexedFieldNames(tvSpec);
 234         }
 235
 236         public override System.Collections.ICollection GetFieldNames(IndexReader.FieldOption fieldNames)
 237         {
 238             return in_Renamed.GetFieldNames(fieldNames);
 239         }
 240     }
 241 }