FieldEnumerator.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;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using Lucene.Net.Util;

namespace Lucene.Net.Index
{
    public enum FieldParser
    {
        String,
        Numeric
    }

    public abstract class FieldEnumerator<T> : IDisposable
    {
        protected bool includeDocs;

        private TermEnum termEnum;

        private TermDocs termDocs;

        protected TermEnumerator tEnum;

        private TermDocEnumerator.TermDocUsingTermsEnumerator tdEnum;

        private bool disposed;

        protected void Init(IndexReader reader, string field)
        {
            this.Init(reader, field, true);
        }

        protected void Init(IndexReader reader, string fieldName, bool includeDocs)
        {
            this.termEnum = reader.Terms(new Term(fieldName));
            if (includeDocs)
            {
                this.termDocs = reader.TermDocs();
                this.tdEnum = new TermDocEnumerator.TermDocUsingTermsEnumerator(this.termDocs, this.termEnum);
            }
            this.tEnum = new TermEnumerator(termEnum, termDocs, fieldName, this);
        }

        protected abstract bool TryParse(string s);

        public TermEnumerator Terms
        {
            get { return this.tEnum; }
        }

        public TermDocEnumerator.TermDocUsingTermsEnumerator Docs
        {
            get
            {
                if (this.termDocs == null)
                {
                    throw new NotSupportedException("This instance does not support enumeration over the document ids.");
                }
                else
                {
                    return this.tdEnum;
                }
            }
        }

        #region IDisposable Members

        public void Dispose()
        {
            if (!this.disposed)
            {
                this.disposed = true;
                if (this.termEnum != null)
                {
                    this.termEnum.Close();
                }
                if (this.termDocs != null)
                {
                    this.termDocs.Close();
                }
                GC.SuppressFinalize(this);
            }
        }

        #endregion

        public class TermEnumerator : IEnumerator<T>, IEnumerable<T>
        {
            private TermEnum termEnum;

            private TermDocs termDocs;

            private Term currentTerm;

            protected string fieldName;

            private bool isFirst = true;

            private FieldEnumerator<T> enclosing;

            public TermEnumerator(TermEnum termEnum, TermDocs termDocs, string field, FieldEnumerator<T> enclosing)
            {
                this.termEnum = termEnum;
                this.termDocs = termDocs;
                this.fieldName = field;
                this.enclosing = enclosing;
            }

            #region IEnumerator<T> Members

            public T Current
            {
                get;
                internal set;
            }

            #endregion

            #region IEnumerator Members

            object IEnumerator.Current
            {
                get { return (object)this.Current; }
            }

            public bool MoveNext()
            {
                if (this.isFirst)
                {
                    this.isFirst = false;
                }
                else
                {
                    if (!this.termEnum.Next())
                    {
                        return false;
                    }
                }

                this.currentTerm = termEnum.Term;
                if (this.currentTerm == null || (!this.currentTerm.Field.Equals(this.fieldName)))
                {
                    return false;
                }

                if (this.enclosing.TryParse(this.currentTerm.Text))
                {
                    if (this.termDocs != null)
                    {
                        this.termDocs.Seek(this.termEnum);
                    }
                    return true;
                }

                return false;
            }

            public void Reset()
            {
                throw new NotSupportedException("The enumerator cannot be reset");
            }

            #endregion

            #region IDisposable Members

            public void Dispose()
            {
                // noop
            }

            #endregion

            #region IEnumerable<T> Members

            public IEnumerator<T> GetEnumerator()
            {
                return this;
            }

            #endregion

            #region IEnumerable Members

            IEnumerator IEnumerable.GetEnumerator()
            {
                return this.GetEnumerator();
            }

            #endregion
        }
    }

    public class TermDocEnumerator : IEnumerable<int>, IDisposable
    {
        private TermDocs termDocs;

        public TermDocEnumerator(TermDocs termDocs)
        {
            this.termDocs = termDocs;
        }

        public void Seek(Term t)
        {
            this.termDocs.Seek(t);
        }

        #region IEnumerable<int> Members

        public IEnumerator<int> GetEnumerator()
        {
            return new TermDocUsingTermsEnumerator(this.termDocs);
        }

        #endregion

        #region IEnumerable Members

        IEnumerator IEnumerable.GetEnumerator()
        {
            return this.GetEnumerator();
        }

        #endregion

        #region IDisposable Members

        public void Dispose()
        {
            if (this.termDocs != null)
            {
                termDocs.Close();
            }
        }

        #endregion

        public class TermDocUsingTermsEnumerator : IEnumerable<int>, IEnumerator<int>
        {
            private TermEnum termEnum;

            private TermDocs termDocs;

            internal TermDocUsingTermsEnumerator(TermDocs termDocs)
                : this(termDocs, null)
            { }

            internal TermDocUsingTermsEnumerator(TermDocs td, TermEnum termEnum)
            {
                this.termDocs = td;
                this.termEnum = termEnum;
            }

            internal void Seek(TermEnum te)
            {
                this.termDocs.Seek(te);
            }

            #region IEnumerable<int> Members

            public IEnumerator<int> GetEnumerator()
            {
                return this;
            }

            #endregion

            #region IEnumerable Members

            IEnumerator IEnumerable.GetEnumerator()
            {
                return this.GetEnumerator();
            }

            #endregion

            #region IEnumerator<int> Members

            public int Current
            {
                get { return this.termDocs.Doc; }
            }

            #endregion

            #region IDisposable Members

            public void Dispose()
            {
                // noop as the closing of the underlying
                // TermDocs is handled by the containing class
            }

            #endregion

            #region IEnumerator Members

            object IEnumerator.Current
            {
                get { throw new NotImplementedException(); }
            }

            public bool MoveNext()
            {
                return this.termDocs.Next();
            }

            public void Reset()
            {
                throw new NotImplementedException();
            }

            #endregion
        }
    }


    public class StringFieldEnumerator : FieldEnumerator<string>
    {
        public StringFieldEnumerator(IndexReader reader, string fieldName)
        {
            this.Init(reader, fieldName);
        }

        public StringFieldEnumerator(IndexReader reader, string fieldName, bool includeDocs)
        {
            this.Init(reader, fieldName, includeDocs);
        }

        protected override bool TryParse(string s)
        {
            this.tEnum.Current = s;
            return true;
        }
    }

    public abstract class NumericFieldEnum<T> : FieldEnumerator<T>
    {
        private FieldParser parser;

        protected void Init(IndexReader reader, string field, bool includeDocs, FieldParser parser)
        {
            base.Init(reader, field, includeDocs);
            this.parser = parser;
        }

        protected override bool TryParse(string s)
        {
            if (this.parser == FieldParser.Numeric)
            {
                return this.TryParseNumeric(s);
            }
            else
            {
                return this.TryParseString(s);
            }
        }

        protected abstract bool TryParseString(string s);

        protected abstract bool TryParseNumeric(string s);
    }

    public class IntFieldEnumerator : NumericFieldEnum<int>
    {
        public IntFieldEnumerator(IndexReader reader, string fieldName, FieldParser parser)
        {
            this.Init(reader, fieldName, true, parser);
        }

        public IntFieldEnumerator(IndexReader reader, string fieldName, FieldParser parser, bool includeDocs)
        {
            this.Init(reader, fieldName, includeDocs, parser);
        }

        protected override bool TryParseString(string s)
        {
            this.tEnum.Current = Int32.Parse(s);
            return true;
        }

        protected override bool TryParseNumeric(string s)
        {
            int shift = s[0] - NumericUtils.SHIFT_START_INT;
            if (shift > 0 && shift <= 31)
            {
                return false;
            }
            else
            {
                this.tEnum.Current = NumericUtils.PrefixCodedToInt(s);
                return true;
            }
        }
    }

    public class FloatFieldEnumerator : NumericFieldEnum<float>
    {

        public FloatFieldEnumerator(IndexReader reader, string fieldName, FieldParser parser)
        {
            this.Init(reader, fieldName, true, parser);
        }

        public FloatFieldEnumerator(IndexReader reader, string fieldName, FieldParser parser, bool includeDocs)
        {
            this.Init(reader, fieldName, includeDocs, parser);
        }

        protected override bool TryParseString(string s)
        {
            this.tEnum.Current = float.Parse(s);
            return true;
        }

        protected override bool TryParseNumeric(string s)
        {
            int shift = s[0] - NumericUtils.SHIFT_START_INT;
            if (shift > 0 && shift <= 31)
            {
                return false;
            }
            else
            {
                this.tEnum.Current = NumericUtils.SortableIntToFloat(NumericUtils.PrefixCodedToInt(s));
                return true;
            }
        }
    }

    public class DoubleFieldEnumerator : NumericFieldEnum<double>
    {
        public DoubleFieldEnumerator(IndexReader reader, string fieldName, FieldParser parser)
        {
            this.Init(reader, fieldName, true, parser);
        }

        public DoubleFieldEnumerator(IndexReader reader, string fieldName, FieldParser parser, bool includeDocs)
        {
            this.Init(reader, fieldName, includeDocs, parser);
        }

        protected override bool TryParseString(string s)
        {
            this.tEnum.Current = Double.Parse(s);
            return true;
        }

        protected override bool TryParseNumeric(string s)
        {
            int shift = s[0] - NumericUtils.SHIFT_START_LONG;
            if (shift > 0 && shift <= 63)
            {
                return false;
            }
            else
            {
                this.tEnum.Current = NumericUtils.SortableLongToDouble(NumericUtils.PrefixCodedToLong(s));
                return true;
            }
        }
    }

    public class LongFieldEnumerator : NumericFieldEnum<long>
    {
        public LongFieldEnumerator(IndexReader reader, string fieldName, FieldParser parser)
        {
            this.Init(reader, fieldName, true, parser);
        }

        public LongFieldEnumerator(IndexReader reader, string fieldName, FieldParser parser, bool includeDocs)
        {
            this.Init(reader, fieldName, includeDocs, parser);
        }

        protected override bool TryParseString(string s)
        {
            this.tEnum.Current = long.Parse(s);
            return true;
        }

        protected override bool TryParseNumeric(string s)
        {
            int shift = s[0] - NumericUtils.SHIFT_START_LONG;
            if (shift > 0 && shift <= 63)
            {
                return false;
            }
            else
            {
                this.tEnum.Current = NumericUtils.PrefixCodedToLong(s);
                return true;
            }
        }
    }
}