NumericTokenStream.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 Lucene.Net.Analysis.Tokenattributes;
using Lucene.Net.Search;
using AttributeSource = Lucene.Net.Util.AttributeSource;
using NumericUtils = Lucene.Net.Util.NumericUtils;
using NumericField = Lucene.Net.Documents.NumericField;
// javadocs

namespace Lucene.Net.Analysis
{
    
    public sealed class NumericTokenStream : TokenStream
    {
        private void  InitBlock()
        {
            termAtt = AddAttribute<ITermAttribute>();
            typeAtt = AddAttribute<ITypeAttribute>();
            posIncrAtt = AddAttribute<IPositionIncrementAttribute>();
        }
        
        public const System.String TOKEN_TYPE_FULL_PREC = "fullPrecNumeric";
        
        public const System.String TOKEN_TYPE_LOWER_PREC = "lowerPrecNumeric";
        
        public NumericTokenStream():this(NumericUtils.PRECISION_STEP_DEFAULT)
        {
        }
        
        public NumericTokenStream(int precisionStep):base()
        {
            InitBlock();
            this.precisionStep = precisionStep;
            if (precisionStep < 1)
                throw new System.ArgumentException("precisionStep must be >=1");
        }
        
        public NumericTokenStream(AttributeSource source, int precisionStep):base(source)
        {
            InitBlock();
            this.precisionStep = precisionStep;
            if (precisionStep < 1)
                throw new System.ArgumentException("precisionStep must be >=1");
        }
        
        public NumericTokenStream(AttributeFactory factory, int precisionStep):base(factory)
        {
            InitBlock();
            this.precisionStep = precisionStep;
            if (precisionStep < 1)
                throw new System.ArgumentException("precisionStep must be >=1");
        }
        
        public NumericTokenStream SetLongValue(long value_Renamed)
        {
            this.value_Renamed = value_Renamed;
            valSize = 64;
            shift = 0;
            return this;
        }
        
        public NumericTokenStream SetIntValue(int value_Renamed)
        {
            this.value_Renamed = (long) value_Renamed;
            valSize = 32;
            shift = 0;
            return this;
        }
        
        public NumericTokenStream SetDoubleValue(double value_Renamed)
        {
            this.value_Renamed = NumericUtils.DoubleToSortableLong(value_Renamed);
            valSize = 64;
            shift = 0;
            return this;
        }
        
        public NumericTokenStream SetFloatValue(float value_Renamed)
        {
            this.value_Renamed = (long) NumericUtils.FloatToSortableInt(value_Renamed);
            valSize = 32;
            shift = 0;
            return this;
        }
        
        // @Override
        public override void  Reset()
        {
            if (valSize == 0)
                throw new System.SystemException("call set???Value() before usage");
            shift = 0;
        }

        protected override void Dispose(bool disposing)
        {
            // Do nothing.
        }
        
        // @Override
        public override bool IncrementToken()
        {
            if (valSize == 0)
                throw new System.SystemException("call set???Value() before usage");
            if (shift >= valSize)
                return false;
            
            ClearAttributes();
            char[] buffer;
            switch (valSize)
            {
                
                case 64: 
                    buffer = termAtt.ResizeTermBuffer(NumericUtils.BUF_SIZE_LONG);
                    termAtt.SetTermLength(NumericUtils.LongToPrefixCoded(value_Renamed, shift, buffer));
                    break;
                
                
                case 32: 
                    buffer = termAtt.ResizeTermBuffer(NumericUtils.BUF_SIZE_INT);
                    termAtt.SetTermLength(NumericUtils.IntToPrefixCoded((int) value_Renamed, shift, buffer));
                    break;
                
                
                default: 
                    // should not happen
                    throw new System.ArgumentException("valSize must be 32 or 64");
                
            }
            
            typeAtt.Type = (shift == 0)?TOKEN_TYPE_FULL_PREC:TOKEN_TYPE_LOWER_PREC;
            posIncrAtt.PositionIncrement = (shift == 0)?1:0;
            shift += precisionStep;
            return true;
        }
        
        // @Override
        public override System.String ToString()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder("(numeric,valSize=").Append(valSize);
            sb.Append(",precisionStep=").Append(precisionStep).Append(')');
            return sb.ToString();
        }
        
        // members
        private ITermAttribute termAtt;
        private ITypeAttribute typeAtt;
        private IPositionIncrementAttribute posIncrAtt;
        
        private int shift = 0, valSize = 0; // valSize==0 means not initialized
        private readonly int precisionStep;
        
        private long value_Renamed = 0L;
    }
}