diff options
Diffstat (limited to 'src/core/Index/FilterIndexReader.cs')
| -rw-r--r-- | src/core/Index/FilterIndexReader.cs | 388 |
1 files changed, 388 insertions, 0 deletions
diff --git a/src/core/Index/FilterIndexReader.cs b/src/core/Index/FilterIndexReader.cs new file mode 100644 index 0000000..dc61613 --- /dev/null +++ b/src/core/Index/FilterIndexReader.cs @@ -0,0 +1,388 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +using System; + +using Document = Lucene.Net.Documents.Document; +using FieldSelector = Lucene.Net.Documents.FieldSelector; +using Directory = Lucene.Net.Store.Directory; + +namespace Lucene.Net.Index +{ + + /// <summary>A <c>FilterIndexReader</c> contains another IndexReader, which it + /// uses as its basic source of data, possibly transforming the data along the + /// way or providing additional functionality. The class + /// <c>FilterIndexReader</c> itself simply implements all abstract methods + /// of <c>IndexReader</c> with versions that pass all requests to the + /// contained index reader. Subclasses of <c>FilterIndexReader</c> may + /// further override some of these methods and may also provide additional + /// methods and fields. + /// </summary> + public class FilterIndexReader:IndexReader + { + + /// <summary>Base class for filtering <see cref="Lucene.Net.Index.TermDocs" /> implementations. </summary> + public class FilterTermDocs : TermDocs + { + protected internal TermDocs in_Renamed; + + public FilterTermDocs(TermDocs in_Renamed) + { + this.in_Renamed = in_Renamed; + } + + public virtual void Seek(Term term) + { + in_Renamed.Seek(term); + } + public virtual void Seek(TermEnum termEnum) + { + in_Renamed.Seek(termEnum); + } + + public virtual int Doc + { + get { return in_Renamed.Doc; } + } + + public virtual int Freq + { + get { return in_Renamed.Freq; } + } + + public virtual bool Next() + { + return in_Renamed.Next(); + } + public virtual int Read(int[] docs, int[] freqs) + { + return in_Renamed.Read(docs, freqs); + } + public virtual bool SkipTo(int i) + { + return in_Renamed.SkipTo(i); + } + + public void Close() + { + Dispose(); + } + + public void Dispose() + { + Dispose(true); + } + + protected virtual void Dispose(bool disposing) + { + if (disposing) + { + in_Renamed.Close(); + } + } + } + + /// <summary>Base class for filtering <see cref="TermPositions" /> implementations. </summary> + public class FilterTermPositions:FilterTermDocs, TermPositions + { + + public FilterTermPositions(TermPositions in_Renamed):base(in_Renamed) + { + } + + public virtual int NextPosition() + { + return ((TermPositions) this.in_Renamed).NextPosition(); + } + + public virtual int PayloadLength + { + get { return ((TermPositions) this.in_Renamed).PayloadLength; } + } + + public virtual byte[] GetPayload(byte[] data, int offset) + { + return ((TermPositions) this.in_Renamed).GetPayload(data, offset); + } + + + // TODO: Remove warning after API has been finalized + + public virtual bool IsPayloadAvailable + { + get { return ((TermPositions) this.in_Renamed).IsPayloadAvailable; } + } + } + + /// <summary>Base class for filtering <see cref="TermEnum" /> implementations. </summary> + public class FilterTermEnum:TermEnum + { + protected internal TermEnum in_Renamed; + + public FilterTermEnum(TermEnum in_Renamed) + { + this.in_Renamed = in_Renamed; + } + + public override bool Next() + { + return in_Renamed.Next(); + } + + public override Term Term + { + get { return in_Renamed.Term; } + } + + public override int DocFreq() + { + return in_Renamed.DocFreq(); + } + + protected override void Dispose(bool disposing) + { + if (disposing) + { + in_Renamed.Close(); + } + } + } + + protected internal IndexReader in_Renamed; + + /// <summary> <p/>Construct a FilterIndexReader based on the specified base reader. + /// Directory locking for delete, undeleteAll, and setNorm operations is + /// left to the base reader.<p/> + /// <p/>Note that base reader is closed if this FilterIndexReader is closed.<p/> + /// </summary> + /// <param name="in_Renamed">specified base reader. + /// </param> + public FilterIndexReader(IndexReader in_Renamed):base() + { + this.in_Renamed = in_Renamed; + } + + public override Directory Directory() + { + return in_Renamed.Directory(); + } + + public override ITermFreqVector[] GetTermFreqVectors(int docNumber) + { + EnsureOpen(); + return in_Renamed.GetTermFreqVectors(docNumber); + } + + public override ITermFreqVector GetTermFreqVector(int docNumber, System.String field) + { + EnsureOpen(); + return in_Renamed.GetTermFreqVector(docNumber, field); + } + + + public override void GetTermFreqVector(int docNumber, System.String field, TermVectorMapper mapper) + { + EnsureOpen(); + in_Renamed.GetTermFreqVector(docNumber, field, mapper); + } + + public override void GetTermFreqVector(int docNumber, TermVectorMapper mapper) + { + EnsureOpen(); + in_Renamed.GetTermFreqVector(docNumber, mapper); + } + + public override int NumDocs() + { + // Don't call ensureOpen() here (it could affect performance) + return in_Renamed.NumDocs(); + } + + public override int MaxDoc + { + get + { + // Don't call ensureOpen() here (it could affect performance) + return in_Renamed.MaxDoc; + } + } + + public override Document Document(int n, FieldSelector fieldSelector) + { + EnsureOpen(); + return in_Renamed.Document(n, fieldSelector); + } + + public override bool IsDeleted(int n) + { + // Don't call ensureOpen() here (it could affect performance) + return in_Renamed.IsDeleted(n); + } + + public override bool HasDeletions + { + get + { + // Don't call ensureOpen() here (it could affect performance) + return in_Renamed.HasDeletions; + } + } + + protected internal override void DoUndeleteAll() + { + in_Renamed.UndeleteAll(); + } + + public override bool HasNorms(System.String field) + { + EnsureOpen(); + return in_Renamed.HasNorms(field); + } + + public override byte[] Norms(System.String f) + { + EnsureOpen(); + return in_Renamed.Norms(f); + } + + public override void Norms(System.String f, byte[] bytes, int offset) + { + EnsureOpen(); + in_Renamed.Norms(f, bytes, offset); + } + + protected internal override void DoSetNorm(int d, System.String f, byte b) + { + in_Renamed.SetNorm(d, f, b); + } + + public override TermEnum Terms() + { + EnsureOpen(); + return in_Renamed.Terms(); + } + + public override TermEnum Terms(Term t) + { + EnsureOpen(); + return in_Renamed.Terms(t); + } + + public override int DocFreq(Term t) + { + EnsureOpen(); + return in_Renamed.DocFreq(t); + } + + public override TermDocs TermDocs() + { + EnsureOpen(); + return in_Renamed.TermDocs(); + } + + public override TermDocs TermDocs(Term term) + { + EnsureOpen(); + return in_Renamed.TermDocs(term); + } + + public override TermPositions TermPositions() + { + EnsureOpen(); + return in_Renamed.TermPositions(); + } + + protected internal override void DoDelete(int n) + { + in_Renamed.DeleteDocument(n); + } + + protected internal override void DoCommit(System.Collections.Generic.IDictionary<string, string> commitUserData) + { + in_Renamed.Commit(commitUserData); + } + + protected internal override void DoClose() + { + in_Renamed.Close(); + // NOTE: only needed in case someone had asked for + // FieldCache for top-level reader (which is generally + // not a good idea): + Lucene.Net.Search.FieldCache_Fields.DEFAULT.Purge(this); + } + + + public override System.Collections.Generic.ICollection<string> GetFieldNames(IndexReader.FieldOption fieldNames) + { + EnsureOpen(); + return in_Renamed.GetFieldNames(fieldNames); + } + + public override long Version + { + get + { + EnsureOpen(); + return in_Renamed.Version; + } + } + + public override bool IsCurrent() + { + EnsureOpen(); + return in_Renamed.IsCurrent(); + } + + public override bool IsOptimized() + { + EnsureOpen(); + return in_Renamed.IsOptimized(); + } + + public override IndexReader[] GetSequentialSubReaders() + { + return in_Renamed.GetSequentialSubReaders(); + } + + override public System.Object Clone() + { + System.Diagnostics.Debug.Fail("Port issue:", "Lets see if we need this FilterIndexReader.Clone()"); // {{Aroush-2.9}} + return null; + } + + /// <summary> + /// If the subclass of FilteredIndexReader modifies the + /// contents of the FieldCache, you must override this + /// method to provide a different key */ + ///</summary> + public override object FieldCacheKey + { + get { return in_Renamed.FieldCacheKey; } + } + + /// <summary> + /// If the subclass of FilteredIndexReader modifies the + /// deleted docs, you must override this method to provide + /// a different key */ + /// </summary> + public override object DeletesCacheKey + { + get { return in_Renamed.DeletesCacheKey; } + } + } +}
\ No newline at end of file |