PositionBasedTermVectorMapper.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 System.Collections.Generic;
using Lucene.Net.Support;

namespace Lucene.Net.Index
{
    
    public class PositionBasedTermVectorMapper:TermVectorMapper
    {
        private IDictionary<string, IDictionary<int, TVPositionInfo>> fieldToTerms;
        
        private System.String currentField;
        private IDictionary<int, TVPositionInfo> currentPositions;
        private bool storeOffsets;
        
        public PositionBasedTermVectorMapper():base(false, false)
        {
        }
        
        public PositionBasedTermVectorMapper(bool ignoringOffsets):base(false, ignoringOffsets)
        {
        }

        public override bool IsIgnoringPositions
        {
            get { return false; }
        }

        public override void  Map(System.String term, int frequency, TermVectorOffsetInfo[] offsets, int[] positions)
        {
            for (int i = 0; i < positions.Length; i++)
            {
                System.Int32 posVal =  positions[i];
                TVPositionInfo pos = currentPositions[posVal];
                if (pos == null)
                {
                    pos = new TVPositionInfo(positions[i], storeOffsets);
                    currentPositions[posVal] = pos;
                }
                pos.addTerm(term, offsets != null ? offsets[i] : TermVectorOffsetInfo.Null);
            }
        }
        
        public override void  SetExpectations(System.String field, int numTerms, bool storeOffsets, bool storePositions)
        {
            if (storePositions == false)
            {
                throw new System.SystemException("You must store positions in order to use this Mapper");
            }
            if (storeOffsets == true)
            {
                //ignoring offsets
            }
            fieldToTerms = new HashMap<string, IDictionary<int, TVPositionInfo>>(numTerms);
            this.storeOffsets = storeOffsets;
            currentField = field;
            currentPositions = new HashMap<int, TVPositionInfo>();
            fieldToTerms[currentField] = currentPositions;
        }

        public virtual IDictionary<string, IDictionary<int, TVPositionInfo>> FieldToTerms
        {
            get { return fieldToTerms; }
        }

        public class TVPositionInfo
        {
            virtual public int Position
            {
                get
                {
                    return position;
                }
                
            }
            virtual public IList<String> Terms
            {
                get
                {
                    return terms;
                }
                
            }
            virtual public IList<TermVectorOffsetInfo> Offsets
            {
                get
                {
                    return offsets;
                }
                
            }
            private int position;
            //a list of Strings
            private IList<string> terms;
            //A list of TermVectorOffsetInfo
            private IList<TermVectorOffsetInfo> offsets;
            
            
            public TVPositionInfo(int position, bool storeOffsets)
            {
                this.position = position;
                terms = new List<string>();
                if (storeOffsets)
                {
                    offsets = new List<TermVectorOffsetInfo>();
                }
            }
            
            internal virtual void  addTerm(System.String term, TermVectorOffsetInfo info)
            {
                terms.Add(term);
                if (offsets != null)
                {
                    offsets.Add(info);
                }
            }
        }
    }
}