FieldCache.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.IO;
using Lucene.Net.Support;
using Double = Lucene.Net.Support.Double;
using NumericTokenStream = Lucene.Net.Analysis.NumericTokenStream;
using NumericField = Lucene.Net.Documents.NumericField;
using IndexReader = Lucene.Net.Index.IndexReader;
using NumericUtils = Lucene.Net.Util.NumericUtils;
using RamUsageEstimator = Lucene.Net.Util.RamUsageEstimator;
using Single = Lucene.Net.Support.Single;

namespace Lucene.Net.Search
{

    public sealed class CreationPlaceholder
    {
        internal System.Object value_Renamed;
    }
    public class StringIndex
    {

        public virtual int BinarySearchLookup(System.String key)
        {
            // this special case is the reason that Arrays.binarySearch() isn't useful.
            if (key == null)
                return 0;

            int low = 1;
            int high = lookup.Length - 1;

            while (low <= high)
            {
                int mid = Number.URShift((low + high), 1);
                int cmp = String.CompareOrdinal(lookup[mid], key);

                if (cmp < 0)
                    low = mid + 1;
                else if (cmp > 0)
                    high = mid - 1;
                else
                    return mid; // key found
            }
            return -(low + 1); // key not found.
        }

        public System.String[] lookup;

        public int[] order;

        public StringIndex(int[] values, System.String[] lookup)
        {
            this.order = values;
            this.lookup = lookup;
        }
    }
    public abstract class CacheEntry
    {
        public abstract object ReaderKey { get; }
        public abstract string FieldName { get; }
        public abstract Type CacheType { get; }
        public abstract object Custom { get; }
        public abstract object Value { get; }

        public virtual void EstimateSize()
        {
            EstimateSize(new RamUsageEstimator(false)); // doesn't check for interned
        }
        public virtual void EstimateSize(RamUsageEstimator ramCalc)
        {
            long size = ramCalc.EstimateRamUsage(Value);
            EstimatedSize = RamUsageEstimator.HumanReadableUnits(size, new System.Globalization.NumberFormatInfo());  // {{Aroush-2.9}} in Java, the formater is set to "0.#", so we need to do the same in C#
        }

        public string EstimatedSize { get; protected internal set; }


        public override System.String ToString()
        {
            var b = new System.Text.StringBuilder();
            b.Append("'").Append(ReaderKey).Append("'=>");
            b.Append("'").Append(FieldName).Append("',");
            b.Append(CacheType).Append(",").Append(Custom);
            b.Append("=>").Append(Value.GetType().FullName).Append("#");
            b.Append(Value.GetHashCode());

            System.String s = EstimatedSize;
            if (null != s)
            {
                b.Append(" (size =~ ").Append(s).Append(')');
            }

            return b.ToString();
        }
    }
    public struct FieldCache_Fields
    {
        // NOTE: the value assigned to this constant must not be
        // the same as any of those in SortField!!
        public readonly static int STRING_INDEX = -1;
        public readonly static FieldCache DEFAULT;
        public readonly static ByteParser DEFAULT_BYTE_PARSER;
        public readonly static ShortParser DEFAULT_SHORT_PARSER;
        public readonly static IntParser DEFAULT_INT_PARSER;
        public readonly static FloatParser DEFAULT_FLOAT_PARSER;
        public readonly static LongParser DEFAULT_LONG_PARSER;
        public readonly static DoubleParser DEFAULT_DOUBLE_PARSER;
        public readonly static IntParser NUMERIC_UTILS_INT_PARSER;
        public readonly static FloatParser NUMERIC_UTILS_FLOAT_PARSER;
        public readonly static LongParser NUMERIC_UTILS_LONG_PARSER;
        public readonly static DoubleParser NUMERIC_UTILS_DOUBLE_PARSER;
        static FieldCache_Fields()
        {
            DEFAULT = new FieldCacheImpl();
            DEFAULT_BYTE_PARSER = new AnonymousClassByteParser();
            DEFAULT_SHORT_PARSER = new AnonymousClassShortParser();
            DEFAULT_INT_PARSER = new AnonymousClassIntParser();
            DEFAULT_FLOAT_PARSER = new AnonymousClassFloatParser();
            DEFAULT_LONG_PARSER = new AnonymousClassLongParser();
            DEFAULT_DOUBLE_PARSER = new AnonymousClassDoubleParser();
            NUMERIC_UTILS_INT_PARSER = new AnonymousClassIntParser1();
            NUMERIC_UTILS_FLOAT_PARSER = new AnonymousClassFloatParser1();
            NUMERIC_UTILS_LONG_PARSER = new AnonymousClassLongParser1();
            NUMERIC_UTILS_DOUBLE_PARSER = new AnonymousClassDoubleParser1();
        }
    }

    [Serializable]
    class AnonymousClassByteParser : ByteParser
    {
        public virtual sbyte ParseByte(System.String value_Renamed)
        {
            return System.SByte.Parse(value_Renamed);
        }
        protected internal virtual System.Object ReadResolve()
        {
            return Lucene.Net.Search.FieldCache_Fields.DEFAULT_BYTE_PARSER;
        }
        public override System.String ToString()
        {
            return typeof(FieldCache).FullName + ".DEFAULT_BYTE_PARSER";
        }
    }
    [Serializable]
    class AnonymousClassShortParser : ShortParser
    {
        public virtual short ParseShort(System.String value_Renamed)
        {
            return System.Int16.Parse(value_Renamed);
        }
        protected internal virtual System.Object ReadResolve()
        {
            return Lucene.Net.Search.FieldCache_Fields.DEFAULT_SHORT_PARSER;
        }
        public override System.String ToString()
        {
            return typeof(FieldCache).FullName + ".DEFAULT_SHORT_PARSER";
        }
    }
    [Serializable]
    class AnonymousClassIntParser : IntParser
    {
        public virtual int ParseInt(System.String value_Renamed)
        {
            return System.Int32.Parse(value_Renamed);
        }
        protected internal virtual System.Object ReadResolve()
        {
            return Lucene.Net.Search.FieldCache_Fields.DEFAULT_INT_PARSER;
        }
        public override System.String ToString()
        {
            return typeof(FieldCache).FullName + ".DEFAULT_INT_PARSER";
        }
    }
    [Serializable]
    class AnonymousClassFloatParser : FloatParser
    {
        public virtual float ParseFloat(System.String value_Renamed)
        {
            try
            {
                return Single.Parse(value_Renamed);
            }
            catch (System.OverflowException)
            {
                return value_Renamed.StartsWith("-") ? float.PositiveInfinity : float.NegativeInfinity;
            }
        }
        protected internal virtual System.Object ReadResolve()
        {
            return Lucene.Net.Search.FieldCache_Fields.DEFAULT_FLOAT_PARSER;
        }
        public override System.String ToString()
        {
            return typeof(FieldCache).FullName + ".DEFAULT_FLOAT_PARSER";
        }
    }
    [Serializable]
    class AnonymousClassLongParser : LongParser
    {
        public virtual long ParseLong(System.String value_Renamed)
        {
            return System.Int64.Parse(value_Renamed);
        }
        protected internal virtual System.Object ReadResolve()
        {
            return Lucene.Net.Search.FieldCache_Fields.DEFAULT_LONG_PARSER;
        }
        public override System.String ToString()
        {
            return typeof(FieldCache).FullName + ".DEFAULT_LONG_PARSER";
        }
    }
    [Serializable]
    class AnonymousClassDoubleParser : DoubleParser
    {
        public virtual double ParseDouble(System.String value_Renamed)
        {
            return Double.Parse(value_Renamed);
        }
        protected internal virtual System.Object ReadResolve()
        {
            return Lucene.Net.Search.FieldCache_Fields.DEFAULT_DOUBLE_PARSER;
        }
        public override System.String ToString()
        {
            return typeof(FieldCache).FullName + ".DEFAULT_DOUBLE_PARSER";
        }
    }
    [Serializable]
    class AnonymousClassIntParser1 : IntParser
    {
        public virtual int ParseInt(System.String val)
        {
            int shift = val[0] - NumericUtils.SHIFT_START_INT;
            if (shift > 0 && shift <= 31)
                throw new FieldCacheImpl.StopFillCacheException();
            return NumericUtils.PrefixCodedToInt(val);
        }
        protected internal virtual System.Object ReadResolve()
        {
            return Lucene.Net.Search.FieldCache_Fields.NUMERIC_UTILS_INT_PARSER;
        }
        public override System.String ToString()
        {
            return typeof(FieldCache).FullName + ".NUMERIC_UTILS_INT_PARSER";
        }
    }
    [Serializable]
    class AnonymousClassFloatParser1 : FloatParser
    {
        public virtual float ParseFloat(System.String val)
        {
            int shift = val[0] - NumericUtils.SHIFT_START_INT;
            if (shift > 0 && shift <= 31)
                throw new FieldCacheImpl.StopFillCacheException();
            return NumericUtils.SortableIntToFloat(NumericUtils.PrefixCodedToInt(val));
        }
        protected internal virtual System.Object ReadResolve()
        {
            return Lucene.Net.Search.FieldCache_Fields.NUMERIC_UTILS_FLOAT_PARSER;
        }
        public override System.String ToString()
        {
            return typeof(FieldCache).FullName + ".NUMERIC_UTILS_FLOAT_PARSER";
        }
    }
    [Serializable]
    class AnonymousClassLongParser1 : LongParser
    {
        public virtual long ParseLong(System.String val)
        {
            int shift = val[0] - NumericUtils.SHIFT_START_LONG;
            if (shift > 0 && shift <= 63)
                throw new FieldCacheImpl.StopFillCacheException();
            return NumericUtils.PrefixCodedToLong(val);
        }
        protected internal virtual System.Object ReadResolve()
        {
            return Lucene.Net.Search.FieldCache_Fields.NUMERIC_UTILS_LONG_PARSER;
        }
        public override System.String ToString()
        {
            return typeof(FieldCache).FullName + ".NUMERIC_UTILS_LONG_PARSER";
        }
    }
    [Serializable]
    class AnonymousClassDoubleParser1 : DoubleParser
    {
        public virtual double ParseDouble(System.String val)
        {
            int shift = val[0] - NumericUtils.SHIFT_START_LONG;
            if (shift > 0 && shift <= 63)
                throw new FieldCacheImpl.StopFillCacheException();
            return NumericUtils.SortableLongToDouble(NumericUtils.PrefixCodedToLong(val));
        }
        protected internal virtual System.Object ReadResolve()
        {
            return Lucene.Net.Search.FieldCache_Fields.NUMERIC_UTILS_DOUBLE_PARSER;
        }
        public override System.String ToString()
        {
            return typeof(FieldCache).FullName + ".NUMERIC_UTILS_DOUBLE_PARSER";
        }
    }

    public interface FieldCache
    {

        sbyte[] GetBytes(IndexReader reader, System.String field);

        sbyte[] GetBytes(IndexReader reader, System.String field, ByteParser parser);

        short[] GetShorts(IndexReader reader, System.String field);

        short[] GetShorts(IndexReader reader, System.String field, ShortParser parser);

        int[] GetInts(IndexReader reader, System.String field);

        int[] GetInts(IndexReader reader, System.String field, IntParser parser);

        float[] GetFloats(IndexReader reader, System.String field);

        float[] GetFloats(IndexReader reader, System.String field, FloatParser parser);

        long[] GetLongs(IndexReader reader, System.String field);

        long[] GetLongs(IndexReader reader, System.String field, LongParser parser);


        double[] GetDoubles(IndexReader reader, System.String field);

        double[] GetDoubles(IndexReader reader, System.String field, DoubleParser parser);

        System.String[] GetStrings(IndexReader reader, System.String field);

        StringIndex GetStringIndex(IndexReader reader, System.String field);

        CacheEntry[] GetCacheEntries();

        void PurgeAllCaches();

        void Purge(IndexReader r);

        StreamWriter InfoStream { get; set; }
    }

    public interface Parser
    {
    }

    public interface ByteParser : Parser
    {
        sbyte ParseByte(System.String string_Renamed);
    }

    public interface ShortParser : Parser
    {
        short ParseShort(System.String string_Renamed);
    }

    public interface IntParser : Parser
    {
        int ParseInt(System.String string_Renamed);
    }

    public interface FloatParser : Parser
    {
        float ParseFloat(System.String string_Renamed);
    }

    public interface LongParser : Parser
    {
        long ParseLong(System.String string_Renamed);
    }

    public interface DoubleParser : Parser
    {
        double ParseDouble(System.String string_Renamed);
    }
}