IndexReader.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.Documents;
using Document = Lucene.Net.Documents.Document;
using FieldSelector = Lucene.Net.Documents.FieldSelector;
using Lucene.Net.Store;
using Similarity = Lucene.Net.Search.Similarity;

namespace Lucene.Net.Index
{
    
    public abstract class IndexReader : System.ICloneable, System.IDisposable
    {
        private class AnonymousClassFindSegmentsFile : SegmentInfos.FindSegmentsFile
        {
            private void  InitBlock(Lucene.Net.Store.Directory directory2)
            {
                this.directory2 = directory2;
            }
            private Lucene.Net.Store.Directory directory2;
            internal AnonymousClassFindSegmentsFile(Lucene.Net.Store.Directory directory2, Lucene.Net.Store.Directory Param1):base(Param1)
            {
                InitBlock(directory2);
            }
            public override System.Object DoBody(System.String segmentFileName)
            {
                return (long) directory2.FileModified(segmentFileName);
            }
        }
        
        public sealed class FieldOption
        {
            private readonly System.String option;
            internal FieldOption()
            {
            }
            internal FieldOption(System.String option)
            {
                this.option = option;
            }
            public override System.String ToString()
            {
                return this.option;
            }
            public static readonly FieldOption ALL = new FieldOption("ALL");
            public static readonly FieldOption INDEXED = new FieldOption("INDEXED");
            public static readonly FieldOption STORES_PAYLOADS = new FieldOption("STORES_PAYLOADS");
            public static readonly FieldOption OMIT_TERM_FREQ_AND_POSITIONS = new FieldOption("OMIT_TERM_FREQ_AND_POSITIONS");
            public static readonly FieldOption UNINDEXED = new FieldOption("UNINDEXED");
            public static readonly FieldOption INDEXED_WITH_TERMVECTOR = new FieldOption("INDEXED_WITH_TERMVECTOR");
            public static readonly FieldOption INDEXED_NO_TERMVECTOR = new FieldOption("INDEXED_NO_TERMVECTOR");
            public static readonly FieldOption TERMVECTOR = new FieldOption("TERMVECTOR");
            public static readonly FieldOption TERMVECTOR_WITH_POSITION = new FieldOption("TERMVECTOR_WITH_POSITION");
            public static readonly FieldOption TERMVECTOR_WITH_OFFSET = new FieldOption("TERMVECTOR_WITH_OFFSET");
            public static readonly FieldOption TERMVECTOR_WITH_POSITION_OFFSET = new FieldOption("TERMVECTOR_WITH_POSITION_OFFSET");
        }
        
        private bool closed;
        protected internal bool hasChanges;
        
        private int refCount;
        
        protected internal static int DEFAULT_TERMS_INDEX_DIVISOR = 1;

        public virtual int RefCount
        {
            get
            {
                lock (this)
                {
                    return refCount;
                }
            }
        }

        public virtual void  IncRef()
        {
            lock (this)
            {
                System.Diagnostics.Debug.Assert(refCount > 0);
                EnsureOpen();
                refCount++;
            }
        }
        
        public virtual void  DecRef()
        {
            lock (this)
            {
                System.Diagnostics.Debug.Assert(refCount > 0);
                EnsureOpen();
                if (refCount == 1)
                {
                    Commit();
                    DoClose();
                }
                refCount--;
            }
        }
        
        protected internal IndexReader()
        {
            refCount = 1;
        }
        
        protected internal void EnsureOpen()
        {
            if (refCount <= 0)
            {
                throw new AlreadyClosedException("this IndexReader is closed");
            }
        }
        
        public static IndexReader Open(Directory directory, bool readOnly)
        {
            return Open(directory, null, null, readOnly, DEFAULT_TERMS_INDEX_DIVISOR);
        }
        
        public static IndexReader Open(IndexCommit commit, bool readOnly)
        {
            return Open(commit.Directory, null, commit, readOnly, DEFAULT_TERMS_INDEX_DIVISOR);
        }
        
        public static IndexReader Open(Directory directory, IndexDeletionPolicy deletionPolicy, bool readOnly)
        {
            return Open(directory, deletionPolicy, null, readOnly, DEFAULT_TERMS_INDEX_DIVISOR);
        }

        public static IndexReader Open(Directory directory, IndexDeletionPolicy deletionPolicy, bool readOnly, int termInfosIndexDivisor)
        {
            return Open(directory, deletionPolicy, null, readOnly, termInfosIndexDivisor);
        }
        
        public static IndexReader Open(IndexCommit commit, IndexDeletionPolicy deletionPolicy, bool readOnly)
        {
            return Open(commit.Directory, deletionPolicy, commit, readOnly, DEFAULT_TERMS_INDEX_DIVISOR);
        }

        public static IndexReader Open(IndexCommit commit, IndexDeletionPolicy deletionPolicy, bool readOnly, int termInfosIndexDivisor)
        {
            return Open(commit.Directory, deletionPolicy, commit, readOnly, termInfosIndexDivisor);
        }
        
        private static IndexReader Open(Directory directory, IndexDeletionPolicy deletionPolicy, IndexCommit commit, bool readOnly, int termInfosIndexDivisor)
        {
            return DirectoryReader.Open(directory, deletionPolicy, commit, readOnly, termInfosIndexDivisor);
        }
        
        public virtual IndexReader Reopen()
        {
            lock (this)
            {
                throw new NotSupportedException("This reader does not support reopen().");
            }
        }
        
        
        public virtual IndexReader Reopen(bool openReadOnly)
        {
            lock (this)
            {
                throw new NotSupportedException("This reader does not support reopen().");
            }
        }
        
        public virtual IndexReader Reopen(IndexCommit commit)
        {
            lock (this)
            {
                throw new NotSupportedException("This reader does not support reopen(IndexCommit).");
            }
        }
        
        public virtual System.Object Clone()
        {
            throw new System.NotSupportedException("This reader does not implement clone()");
        }
        
        public virtual IndexReader Clone(bool openReadOnly)
        {
            lock (this)
            {
                throw new System.NotSupportedException("This reader does not implement clone()");
            }
        }
        
        public virtual Directory Directory()
        {
            EnsureOpen();
            throw new NotSupportedException("This reader does not support this method.");
        }
        
        public static long LastModified(Directory directory2)
        {
            return (long) ((System.Int64) new AnonymousClassFindSegmentsFile(directory2, directory2).Run());
        }
        
        public static long GetCurrentVersion(Directory directory)
        {
            return SegmentInfos.ReadCurrentVersion(directory);
        }

        public static System.Collections.Generic.IDictionary<string, string> GetCommitUserData(Directory directory)
        {
            return SegmentInfos.ReadCurrentUserData(directory);
        }

        public virtual long Version
        {
            get { throw new System.NotSupportedException("This reader does not support this method."); }
        }

        public virtual IDictionary<string, string> CommitUserData
        {
            get { throw new System.NotSupportedException("This reader does not support this method."); }
        }

        public virtual bool IsCurrent()
        {
            throw new NotSupportedException("This reader does not support this method.");
        }

        public virtual bool IsOptimized()
        {
            throw new NotSupportedException("This reader does not support this method.");
        }

        abstract public ITermFreqVector[] GetTermFreqVectors(int docNumber);
        
        
        abstract public ITermFreqVector GetTermFreqVector(int docNumber, String field);
        
        abstract public void  GetTermFreqVector(int docNumber, String field, TermVectorMapper mapper);
        
        abstract public void  GetTermFreqVector(int docNumber, TermVectorMapper mapper);
        
        public static bool IndexExists(Directory directory)
        {
            return SegmentInfos.GetCurrentSegmentGeneration(directory) != - 1;
        }

        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate")]
        public abstract int NumDocs();

        public abstract int MaxDoc { get; }

        public virtual int NumDeletedDocs
        {
            get { return MaxDoc - NumDocs(); }
        }

        public virtual Document Document(int n)
        {
            EnsureOpen();
            return Document(n, null);
        }

        public Document this[int doc]
        {
            get { return Document(doc); }
        }
        
        // TODO (1.5): When we convert to JDK 1.5 make this Set<String>
        public abstract Document Document(int n, FieldSelector fieldSelector);
        
        public abstract bool IsDeleted(int n);

        public abstract bool HasDeletions { get; }

        public virtual bool HasNorms(System.String field)
        {
            // backward compatible implementation.
            // SegmentReader has an efficient implementation.
            EnsureOpen();
            return Norms(field) != null;
        }

        public abstract byte[] Norms(System.String field);
        
        public abstract void  Norms(System.String field, byte[] bytes, int offset);
        
        public virtual void  SetNorm(int doc, String field, byte value)
        {
            lock (this)
            {
                EnsureOpen();
                AcquireWriteLock();
                hasChanges = true;
                DoSetNorm(doc, field, value);
            }
        }
        
        protected internal abstract void  DoSetNorm(int doc, System.String field, byte value_Renamed);
        
        public virtual void  SetNorm(int doc, System.String field, float value)
        {
            EnsureOpen();
            SetNorm(doc, field, Similarity.EncodeNorm(value));
        }
        
        public abstract TermEnum Terms();
        
        public abstract TermEnum Terms(Term t);

        public abstract int DocFreq(Term t);
        
        public virtual TermDocs TermDocs(Term term)
        {
            EnsureOpen();
            TermDocs termDocs = TermDocs();
            termDocs.Seek(term);
            return termDocs;
        }

        public abstract TermDocs TermDocs();
        
        public virtual TermPositions TermPositions(Term term)
        {
            EnsureOpen();
            TermPositions termPositions = TermPositions();
            termPositions.Seek(term);
            return termPositions;
        }

        public abstract TermPositions TermPositions();
        
        
        
        public virtual void  DeleteDocument(int docNum)
        {
            lock (this)
            {
                EnsureOpen();
                AcquireWriteLock();
                hasChanges = true;
                DoDelete(docNum);
            }
        }
        
        
        protected internal abstract void  DoDelete(int docNum);
        
        
        public virtual int DeleteDocuments(Term term)
        {
            EnsureOpen();
            TermDocs docs = TermDocs(term);
            if (docs == null)
                return 0;
            int n = 0;
            try
            {
                while (docs.Next())
                {
                    DeleteDocument(docs.Doc);
                    n++;
                }
            }
            finally
            {
                docs.Close();
            }
            return n;
        }
        
        public virtual void  UndeleteAll()
        {
            lock (this)
            {
                EnsureOpen();
                AcquireWriteLock();
                hasChanges = true;
                DoUndeleteAll();
            }
        }
        
        protected internal abstract void  DoUndeleteAll();
        
        protected internal virtual void  AcquireWriteLock()
        {
            lock (this)
            {
                /* NOOP */
            }
        }
        
        public void  Flush()
        {
            lock (this)
            {
                EnsureOpen();
                Commit();
            }
        }
        
        public void Flush(IDictionary<string, string> commitUserData)
        {
            lock (this)
            {
                EnsureOpen();
                Commit(commitUserData);
            }
        }
        
        public /*protected internal*/ void  Commit()
        {
            lock (this)
            {
                Commit(null);
            }
        }
        
        public void Commit(IDictionary<string, string> commitUserData)
        {
            lock (this)
            {
                if (hasChanges)
                {
                    DoCommit(commitUserData);
                }
                hasChanges = false;
            }
        }
        
        protected internal abstract void DoCommit(IDictionary<string, string> commitUserData);

        [Obsolete("Use Dispose() instead")]
        public void Close()
        {
            Dispose();
        }

        public void Dispose()
        {
            Dispose(true);
        }

        protected virtual void Dispose(bool disposing)
        {
            if (disposing)
            {
                lock (this)
                {
                    if (!closed)
                    {
                        DecRef();
                        closed = true;
                    }
                }
            }
        }
        
        protected internal abstract void  DoClose();
        
        
        public abstract ICollection<string> GetFieldNames(FieldOption fldOption);

        public virtual IndexCommit IndexCommit
        {
            get { throw new NotSupportedException("This reader does not support this method."); }
        }

        [STAThread]
        public static void  Main(String[] args)
        {
            System.String filename = null;
            bool extract = false;
            
            foreach (string t in args)
            {
                if (t.Equals("-extract"))
                {
                    extract = true;
                }
                else if (filename == null)
                {
                    filename = t;
                }
            }

            if (filename == null)
            {
                System.Console.Out.WriteLine("Usage: Lucene.Net.Index.IndexReader [-extract] <cfsfile>");
                return ;
            }
            
            Directory dir = null;
            CompoundFileReader cfr = null;
            
            try
            {
                var file = new System.IO.FileInfo(filename);
                System.String dirname = new System.IO.FileInfo(file.FullName).DirectoryName;
                filename = file.Name;
                dir = FSDirectory.Open(new System.IO.DirectoryInfo(dirname));
                cfr = new CompoundFileReader(dir, filename);
                
                System.String[] files = cfr.ListAll();
                System.Array.Sort(files); // sort the array of filename so that the output is more readable
                
                foreach (string t in files)
                {
                    long len = cfr.FileLength(t);
                    
                    if (extract)
                    {
                        System.Console.Out.WriteLine("extract " + t + " with " + len + " bytes to local directory...");
                        IndexInput ii = cfr.OpenInput(t);
                        
                        var f = new System.IO.FileStream(t, System.IO.FileMode.Create);
                        
                        // read and write with a small buffer, which is more effectiv than reading byte by byte
                        var buffer = new byte[1024];
                        int chunk = buffer.Length;
                        while (len > 0)
                        {
                            var bufLen = (int) System.Math.Min(chunk, len);
                            ii.ReadBytes(buffer, 0, bufLen);
                            f.Write(buffer, 0, bufLen);
                            len -= bufLen;
                        }
                        
                        f.Close();
                        ii.Close();
                    }
                    else
                        System.Console.Out.WriteLine(t + ": " + len + " bytes");
                }
            }
            catch (System.IO.IOException ioe)
            {
                System.Console.Error.WriteLine(ioe.StackTrace);
            }
            finally
            {
                try
                {
                    if (dir != null)
                        dir.Close();
                    if (cfr != null)
                        cfr.Close();
                }
                catch (System.IO.IOException ioe)
                {
                    System.Console.Error.WriteLine(ioe.StackTrace);
                }
            }
        }
        
        public static System.Collections.Generic.ICollection<IndexCommit> ListCommits(Directory dir)
        {
            return DirectoryReader.ListCommits(dir);
        }

        public virtual IndexReader[] GetSequentialSubReaders()
        {
            return null;
        }

        public virtual object FieldCacheKey
        {
            get { return this; }
        }

        /* Expert.  Warning: this returns null if the reader has
          *  no deletions 
          */

        public virtual object DeletesCacheKey
        {
            get { return this; }
        }

        public virtual long UniqueTermCount
        {
            get { throw new System.NotSupportedException("this reader does not implement getUniqueTermCount()"); }
        }

        public virtual int TermInfosIndexDivisor
        {
            get { throw new NotSupportedException("This reader does not support this method."); }
        }
    }
}