src/Lucene.Net.Core/Index/SegmentTermPositions.cs

/* 
 * 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 Lucene.Net.Support;
using IndexInput = Lucene.Net.Store.IndexInput;

namespace Lucene.Net.Index
{
    internal sealed class SegmentTermPositions : SegmentTermDocs, TermPositions
    {
        private IndexInput proxStream;
        private int proxCount;
        private int position;
        
        // the current payload length
        private int payloadLength;
        // indicates whether the payload of the currend position has
        // been read from the proxStream yet
        private bool needToLoadPayload;
        
        // these variables are being used to remember information
        // for a lazy skip
        private long lazySkipPointer = - 1;
        private int lazySkipProxCount = 0;
        
        internal SegmentTermPositions(SegmentReader p):base(p)
        {
            this.proxStream = null; // the proxStream will be cloned lazily when nextPosition() is called for the first time
        }
        
        internal override void  Seek(TermInfo ti, Term term)
        {
            base.Seek(ti, term);
            if (ti != null)
                lazySkipPointer = ti.proxPointer;
            
            lazySkipProxCount = 0;
            proxCount = 0;
            payloadLength = 0;
            needToLoadPayload = false;
        }
        
        protected override void Dispose(bool disposing)
        {
            base.Dispose(disposing);
            if (proxStream != null)
                proxStream.Dispose();
        }
        
        public int NextPosition()
        {
            if (currentFieldOmitTermFreqAndPositions)
            // This field does not store term freq, positions, payloads
                return 0;
            // perform lazy skips if neccessary
            LazySkip();
            proxCount--;
            return position += ReadDeltaPosition();
        }
        
        private int ReadDeltaPosition()
        {
            int delta = proxStream.ReadVInt();
            if (currentFieldStoresPayloads)
            {
                // if the current field stores payloads then
                // the position delta is shifted one bit to the left.
                // if the LSB is set, then we have to read the current
                // payload length
                if ((delta & 1) != 0)
                {
                    payloadLength = proxStream.ReadVInt();
                }
                delta = Number.URShift(delta, 1);
                needToLoadPayload = true;
            }
            return delta;
        }
        
        protected internal override void  SkippingDoc()
        {
            // we remember to skip a document lazily
            lazySkipProxCount += freq;
        }
        
        public override bool Next()
        {
            // we remember to skip the remaining positions of the current
            // document lazily
            lazySkipProxCount += proxCount;
            
            if (base.Next())
            {
                // run super
                proxCount = freq; // note frequency
                position = 0; // reset position
                return true;
            }
            return false;
        }
        
        public override int Read(int[] docs, int[] freqs)
        {
            throw new System.NotSupportedException("TermPositions does not support processing multiple documents in one call. Use TermDocs instead.");
        }
        
        
        /// <summary>Called by super.skipTo(). </summary>
        protected internal override void  SkipProx(long proxPointer, int payloadLength)
        {
            // we save the pointer, we might have to skip there lazily
            lazySkipPointer = proxPointer;
            lazySkipProxCount = 0;
            proxCount = 0;
            this.payloadLength = payloadLength;
            needToLoadPayload = false;
        }
        
        private void  SkipPositions(int n)
        {
            System.Diagnostics.Debug.Assert(!currentFieldOmitTermFreqAndPositions);
            for (int f = n; f > 0; f--)
            {
                // skip unread positions
                ReadDeltaPosition();
                SkipPayload();
            }
        }
        
        private void  SkipPayload()
        {
            if (needToLoadPayload && payloadLength > 0)
            {
                proxStream.Seek(proxStream.FilePointer + payloadLength);
            }
            needToLoadPayload = false;
        }
        
        // It is not always neccessary to move the prox pointer
        // to a new document after the freq pointer has been moved.
        // Consider for example a phrase query with two terms:
        // the freq pointer for term 1 has to move to document x
        // to answer the question if the term occurs in that document. But
        // only if term 2 also matches document x, the positions have to be
        // read to figure out if term 1 and term 2 appear next
        // to each other in document x and thus satisfy the query.
        // So we move the prox pointer lazily to the document
        // as soon as positions are requested.
        private void  LazySkip()
        {
            if (proxStream == null)
            {
                // clone lazily
                proxStream = (IndexInput) parent.core.proxStream.Clone();
            }
            
            // we might have to skip the current payload
            // if it was not read yet
            SkipPayload();
            
            if (lazySkipPointer != - 1)
            {
                proxStream.Seek(lazySkipPointer);
                lazySkipPointer = - 1;
            }
            
            if (lazySkipProxCount != 0)
            {
                SkipPositions(lazySkipProxCount);
                lazySkipProxCount = 0;
            }
        }

        public int PayloadLength
        {
            get { return payloadLength; }
        }

        public byte[] GetPayload(byte[] data, int offset)
        {
            if (!needToLoadPayload)
            {
                throw new System.IO.IOException("Either no payload exists at this term position or an attempt was made to load it more than once.");
            }
            
            // read payloads lazily
            byte[] retArray;
            int retOffset;
            if (data == null || data.Length - offset < payloadLength)
            {
                // the array is too small to store the payload data,
                // so we allocate a new one
                retArray = new byte[payloadLength];
                retOffset = 0;
            }
            else
            {
                retArray = data;
                retOffset = offset;
            }
            proxStream.ReadBytes(retArray, retOffset, payloadLength);
            needToLoadPayload = false;
            return retArray;
        }

        public bool IsPayloadAvailable
        {
            get { return needToLoadPayload && payloadLength > 0; }
        }
    }
}