FieldCacheTermsFilter.cs

Go to the documentation of this file.

/* 
 * 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 IndexReader = Lucene.Net.Index.IndexReader;
using TermDocs = Lucene.Net.Index.TermDocs;
using OpenBitSet = Lucene.Net.Util.OpenBitSet;

namespace Lucene.Net.Search
{
    
    
    [Serializable]
    public class FieldCacheTermsFilter:Filter
    {
        private readonly string field;
        private readonly string[] terms;
        
        public FieldCacheTermsFilter(string field, params string[] terms)
        {
            this.field = field;
            this.terms = terms;
        }

        public virtual FieldCache FieldCache
        {
            get { return FieldCache_Fields.DEFAULT; }
        }

        public override DocIdSet GetDocIdSet(IndexReader reader)
        {
            return new FieldCacheTermsFilterDocIdSet(this, FieldCache.GetStringIndex(reader, field));
        }
        
        protected internal class FieldCacheTermsFilterDocIdSet:DocIdSet
        {
            private void  InitBlock(FieldCacheTermsFilter enclosingInstance)
            {
                this.enclosingInstance = enclosingInstance;
            }
            private FieldCacheTermsFilter enclosingInstance;
            public FieldCacheTermsFilter Enclosing_Instance
            {
                get
                {
                    return enclosingInstance;
                }
                
            }
            private readonly Lucene.Net.Search.StringIndex fcsi;
            
            private readonly OpenBitSet openBitSet;
            
            public FieldCacheTermsFilterDocIdSet(FieldCacheTermsFilter enclosingInstance, StringIndex fcsi)
            {
                InitBlock(enclosingInstance);
                this.fcsi = fcsi;
                openBitSet = new OpenBitSet(this.fcsi.lookup.Length);
                foreach (string t in Enclosing_Instance.terms)
                {
                    int termNumber = this.fcsi.BinarySearchLookup(t);
                    if (termNumber > 0)
                    {
                        openBitSet.FastSet(termNumber);
                    }
                }
            }
            
            public override DocIdSetIterator Iterator()
            {
                return new FieldCacheTermsFilterDocIdSetIterator(this);
            }

            public override bool IsCacheable
            {
                get { return true; }
            }

            protected internal class FieldCacheTermsFilterDocIdSetIterator:DocIdSetIterator
            {
                public FieldCacheTermsFilterDocIdSetIterator(FieldCacheTermsFilterDocIdSet enclosingInstance)
                {
                    InitBlock(enclosingInstance);
                }
                private void  InitBlock(FieldCacheTermsFilterDocIdSet enclosingInstance)
                {
                    this.enclosingInstance = enclosingInstance;
                }
                private FieldCacheTermsFilterDocIdSet enclosingInstance;
                public FieldCacheTermsFilterDocIdSet Enclosing_Instance
                {
                    get
                    {
                        return enclosingInstance;
                    }
                    
                }
                private int doc = - 1;
                
                public override int DocID()
                {
                    return doc;
                }
                
                public override int NextDoc()
                {
                    try
                    {
                        while (!Enclosing_Instance.openBitSet.FastGet(Enclosing_Instance.fcsi.order[++doc]))
                        {
                        }
                    }
                    catch (IndexOutOfRangeException)
                    {
                        doc = NO_MORE_DOCS;
                    }
                    return doc;
                }
                
                public override int Advance(int target)
                {
                    try
                    {
                        doc = target;
                        while (!Enclosing_Instance.openBitSet.FastGet(Enclosing_Instance.fcsi.order[doc]))
                        {
                            doc++;
                        }
                    }
                    catch (IndexOutOfRangeException)
                    {
                        doc = NO_MORE_DOCS;
                    }
                    return doc;
                }
            }
        }
    }
}