lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ccurr...@apache.org
Subject [10/51] [partial] Mass convert mixed tabs to spaces
Date Wed, 03 Apr 2013 17:39:53 GMT
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/62f018ab/src/core/Index/IndexReader.cs
----------------------------------------------------------------------
diff --git a/src/core/Index/IndexReader.cs b/src/core/Index/IndexReader.cs
index 5c3bd9b..91427c0 100644
--- a/src/core/Index/IndexReader.cs
+++ b/src/core/Index/IndexReader.cs
@@ -25,712 +25,712 @@ using Similarity = Lucene.Net.Search.Similarity;
 
 namespace Lucene.Net.Index
 {
-	
-	/// <summary>IndexReader is an abstract class, providing an interface for accessing an
-	/// index.  Search of an index is done entirely through this abstract interface,
-	/// so that any subclass which implements it is searchable.
-	/// <p/> Concrete subclasses of IndexReader are usually constructed with a call to
-	/// one of the static <c>open()</c> methods, e.g. <see cref="Open(Lucene.Net.Store.Directory, bool)" />
-	///.
-	/// <p/> For efficiency, in this API documents are often referred to via
-	/// <i>document numbers</i>, non-negative integers which each name a unique
-	/// document in the index.  These document numbers are ephemeral--they may change
-	/// as documents are added to and deleted from an index.  Clients should thus not
-	/// rely on a given document having the same number between sessions.
-	/// <p/> An IndexReader can be opened on a directory for which an IndexWriter is
-	/// opened already, but it cannot be used to delete documents from the index then.
-	/// <p/>
-	/// <b>NOTE</b>: for backwards API compatibility, several methods are not listed 
-	/// as abstract, but have no useful implementations in this base class and 
-	/// instead always throw UnsupportedOperationException.  Subclasses are 
-	/// strongly encouraged to override these methods, but in many cases may not 
-	/// need to.
-	/// <p/>
-	/// <p/>
-	/// <b>NOTE</b>: as of 2.4, it's possible to open a read-only
-	/// IndexReader using the static open methods that accepts the
-	/// boolean readOnly parameter.  Such a reader has better
-	/// better concurrency as it's not necessary to synchronize on the
-	/// isDeleted method.  You must explicitly specify false
-	/// if you want to make changes with the resulting IndexReader.
-	/// <p/>
-	/// <a name="thread-safety"></a><p/><b>NOTE</b>: <see cref="IndexReader" />
-	/// instances are completely thread
-	/// safe, meaning multiple threads can call any of its methods,
-	/// concurrently.  If your application requires external
-	/// synchronization, you should <b>not</b> synchronize on the
-	/// <c>IndexReader</c> instance; use your own
-	/// (non-Lucene) objects instead.
-	/// </summary>
-	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);
-			}
-		}
-		
-		/// <summary> Constants describing field properties, for example used for
-		/// <see cref="IndexReader.GetFieldNames(FieldOption)" />.
-		/// </summary>
-		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;
-			}
-			/// <summary>All fields </summary>
-			public static readonly FieldOption ALL = new FieldOption("ALL");
-			/// <summary>All indexed fields </summary>
-			public static readonly FieldOption INDEXED = new FieldOption("INDEXED");
-			/// <summary>All fields that store payloads </summary>
-			public static readonly FieldOption STORES_PAYLOADS = new FieldOption("STORES_PAYLOADS");
-			/// <summary>All fields that omit tf </summary>
-			public static readonly FieldOption OMIT_TERM_FREQ_AND_POSITIONS = new FieldOption("OMIT_TERM_FREQ_AND_POSITIONS");
-			/// <summary>All fields which are not indexed </summary>
-			public static readonly FieldOption UNINDEXED = new FieldOption("UNINDEXED");
-			/// <summary>All fields which are indexed with termvectors enabled </summary>
-			public static readonly FieldOption INDEXED_WITH_TERMVECTOR = new FieldOption("INDEXED_WITH_TERMVECTOR");
-			/// <summary>All fields which are indexed but don't have termvectors enabled </summary>
-			public static readonly FieldOption INDEXED_NO_TERMVECTOR = new FieldOption("INDEXED_NO_TERMVECTOR");
-			/// <summary>All fields with termvectors enabled. Please note that only standard termvector fields are returned </summary>
-			public static readonly FieldOption TERMVECTOR = new FieldOption("TERMVECTOR");
-			/// <summary>All fields with termvectors with position values enabled </summary>
-			public static readonly FieldOption TERMVECTOR_WITH_POSITION = new FieldOption("TERMVECTOR_WITH_POSITION");
-			/// <summary>All fields with termvectors with offset values enabled </summary>
-			public static readonly FieldOption TERMVECTOR_WITH_OFFSET = new FieldOption("TERMVECTOR_WITH_OFFSET");
-			/// <summary>All fields with termvectors with offset values and position values enabled </summary>
-			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;
+    
+    /// <summary>IndexReader is an abstract class, providing an interface for accessing an
+    /// index.  Search of an index is done entirely through this abstract interface,
+    /// so that any subclass which implements it is searchable.
+    /// <p/> Concrete subclasses of IndexReader are usually constructed with a call to
+    /// one of the static <c>open()</c> methods, e.g. <see cref="Open(Lucene.Net.Store.Directory, bool)" />
+    ///.
+    /// <p/> For efficiency, in this API documents are often referred to via
+    /// <i>document numbers</i>, non-negative integers which each name a unique
+    /// document in the index.  These document numbers are ephemeral--they may change
+    /// as documents are added to and deleted from an index.  Clients should thus not
+    /// rely on a given document having the same number between sessions.
+    /// <p/> An IndexReader can be opened on a directory for which an IndexWriter is
+    /// opened already, but it cannot be used to delete documents from the index then.
+    /// <p/>
+    /// <b>NOTE</b>: for backwards API compatibility, several methods are not listed 
+    /// as abstract, but have no useful implementations in this base class and 
+    /// instead always throw UnsupportedOperationException.  Subclasses are 
+    /// strongly encouraged to override these methods, but in many cases may not 
+    /// need to.
+    /// <p/>
+    /// <p/>
+    /// <b>NOTE</b>: as of 2.4, it's possible to open a read-only
+    /// IndexReader using the static open methods that accepts the
+    /// boolean readOnly parameter.  Such a reader has better
+    /// better concurrency as it's not necessary to synchronize on the
+    /// isDeleted method.  You must explicitly specify false
+    /// if you want to make changes with the resulting IndexReader.
+    /// <p/>
+    /// <a name="thread-safety"></a><p/><b>NOTE</b>: <see cref="IndexReader" />
+    /// instances are completely thread
+    /// safe, meaning multiple threads can call any of its methods,
+    /// concurrently.  If your application requires external
+    /// synchronization, you should <b>not</b> synchronize on the
+    /// <c>IndexReader</c> instance; use your own
+    /// (non-Lucene) objects instead.
+    /// </summary>
+    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);
+            }
+        }
+        
+        /// <summary> Constants describing field properties, for example used for
+        /// <see cref="IndexReader.GetFieldNames(FieldOption)" />.
+        /// </summary>
+        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;
+            }
+            /// <summary>All fields </summary>
+            public static readonly FieldOption ALL = new FieldOption("ALL");
+            /// <summary>All indexed fields </summary>
+            public static readonly FieldOption INDEXED = new FieldOption("INDEXED");
+            /// <summary>All fields that store payloads </summary>
+            public static readonly FieldOption STORES_PAYLOADS = new FieldOption("STORES_PAYLOADS");
+            /// <summary>All fields that omit tf </summary>
+            public static readonly FieldOption OMIT_TERM_FREQ_AND_POSITIONS = new FieldOption("OMIT_TERM_FREQ_AND_POSITIONS");
+            /// <summary>All fields which are not indexed </summary>
+            public static readonly FieldOption UNINDEXED = new FieldOption("UNINDEXED");
+            /// <summary>All fields which are indexed with termvectors enabled </summary>
+            public static readonly FieldOption INDEXED_WITH_TERMVECTOR = new FieldOption("INDEXED_WITH_TERMVECTOR");
+            /// <summary>All fields which are indexed but don't have termvectors enabled </summary>
+            public static readonly FieldOption INDEXED_NO_TERMVECTOR = new FieldOption("INDEXED_NO_TERMVECTOR");
+            /// <summary>All fields with termvectors enabled. Please note that only standard termvector fields are returned </summary>
+            public static readonly FieldOption TERMVECTOR = new FieldOption("TERMVECTOR");
+            /// <summary>All fields with termvectors with position values enabled </summary>
+            public static readonly FieldOption TERMVECTOR_WITH_POSITION = new FieldOption("TERMVECTOR_WITH_POSITION");
+            /// <summary>All fields with termvectors with offset values enabled </summary>
+            public static readonly FieldOption TERMVECTOR_WITH_OFFSET = new FieldOption("TERMVECTOR_WITH_OFFSET");
+            /// <summary>All fields with termvectors with offset values and position values enabled </summary>
+            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;
 
-	    /// <summary>Expert: returns the current refCount for this reader </summary>
-	    public virtual int RefCount
-	    {
-	        get
-	        {
-	            lock (this)
-	            {
-	                return refCount;
-	            }
-	        }
-	    }
+        /// <summary>Expert: returns the current refCount for this reader </summary>
+        public virtual int RefCount
+        {
+            get
+            {
+                lock (this)
+                {
+                    return refCount;
+                }
+            }
+        }
 
-	    /// <summary> Expert: increments the refCount of this IndexReader
-		/// instance.  RefCounts are used to determine when a
-		/// reader can be closed safely, i.e. as soon as there are
-		/// no more references.  Be sure to always call a
-		/// corresponding <see cref="DecRef" />, in a finally clause;
-		/// otherwise the reader may never be closed.  Note that
-		/// <see cref="Close" /> simply calls decRef(), which means that
-		/// the IndexReader will not really be closed until <see cref="DecRef" />
-		/// has been called for all outstanding
-		/// references.
-		/// 
-		/// </summary>
-		/// <seealso cref="DecRef">
-		/// </seealso>
-		public virtual void  IncRef()
-		{
-			lock (this)
-			{
-				System.Diagnostics.Debug.Assert(refCount > 0);
-				EnsureOpen();
-				refCount++;
-			}
-		}
-		
-		/// <summary> Expert: decreases the refCount of this IndexReader
-		/// instance.  If the refCount drops to 0, then pending
-		/// changes (if any) are committed to the index and this
-		/// reader is closed.
-		/// 
-		/// </summary>
-		/// <throws>  IOException in case an IOException occurs in commit() or doClose() </throws>
-		/// <summary> 
-		/// </summary>
-		/// <seealso cref="IncRef">
-		/// </seealso>
-		public virtual void  DecRef()
-		{
-			lock (this)
-			{
-				System.Diagnostics.Debug.Assert(refCount > 0);
-				EnsureOpen();
-				if (refCount == 1)
-				{
-					Commit();
-					DoClose();
-				}
-				refCount--;
-			}
-		}
-		
-		protected internal IndexReader()
-		{
-			refCount = 1;
-		}
-		
-		/// <throws>  AlreadyClosedException if this IndexReader is closed </throws>
+        /// <summary> Expert: increments the refCount of this IndexReader
+        /// instance.  RefCounts are used to determine when a
+        /// reader can be closed safely, i.e. as soon as there are
+        /// no more references.  Be sure to always call a
+        /// corresponding <see cref="DecRef" />, in a finally clause;
+        /// otherwise the reader may never be closed.  Note that
+        /// <see cref="Close" /> simply calls decRef(), which means that
+        /// the IndexReader will not really be closed until <see cref="DecRef" />
+        /// has been called for all outstanding
+        /// references.
+        /// 
+        /// </summary>
+        /// <seealso cref="DecRef">
+        /// </seealso>
+        public virtual void  IncRef()
+        {
+            lock (this)
+            {
+                System.Diagnostics.Debug.Assert(refCount > 0);
+                EnsureOpen();
+                refCount++;
+            }
+        }
+        
+        /// <summary> Expert: decreases the refCount of this IndexReader
+        /// instance.  If the refCount drops to 0, then pending
+        /// changes (if any) are committed to the index and this
+        /// reader is closed.
+        /// 
+        /// </summary>
+        /// <throws>  IOException in case an IOException occurs in commit() or doClose() </throws>
+        /// <summary> 
+        /// </summary>
+        /// <seealso cref="IncRef">
+        /// </seealso>
+        public virtual void  DecRef()
+        {
+            lock (this)
+            {
+                System.Diagnostics.Debug.Assert(refCount > 0);
+                EnsureOpen();
+                if (refCount == 1)
+                {
+                    Commit();
+                    DoClose();
+                }
+                refCount--;
+            }
+        }
+        
+        protected internal IndexReader()
+        {
+            refCount = 1;
+        }
+        
+        /// <throws>  AlreadyClosedException if this IndexReader is closed </throws>
         protected internal void EnsureOpen()
-		{
-		    if (refCount <= 0)
-		    {
-		        throw new AlreadyClosedException("this IndexReader is closed");
-		    }
-		}
-		
-		/// <summary>Returns an IndexReader reading the index in the given
-		/// Directory.  You should pass readOnly=true, since it
-		/// gives much better concurrent performance, unless you
-		/// intend to do write operations (delete documents or
-		/// change norms) with the reader.
-		/// </summary>
-		/// <param name="directory">the index directory</param>
+        {
+            if (refCount <= 0)
+            {
+                throw new AlreadyClosedException("this IndexReader is closed");
+            }
+        }
+        
+        /// <summary>Returns an IndexReader reading the index in the given
+        /// Directory.  You should pass readOnly=true, since it
+        /// gives much better concurrent performance, unless you
+        /// intend to do write operations (delete documents or
+        /// change norms) with the reader.
+        /// </summary>
+        /// <param name="directory">the index directory</param>
         /// <param name="readOnly">true if no changes (deletions, norms) will be made with this IndexReader</param>
         /// <exception cref="CorruptIndexException">CorruptIndexException if the index is corrupt</exception>
         /// <exception cref="System.IO.IOException">IOException if there is a low-level IO error</exception>
-		public static IndexReader Open(Directory directory, bool readOnly)
-		{
-			return Open(directory, null, null, readOnly, DEFAULT_TERMS_INDEX_DIVISOR);
-		}
-		
-		/// <summary>Expert: returns an IndexReader reading the index in the given
-		/// <see cref="IndexCommit" />.  You should pass readOnly=true, since it
-		/// gives much better concurrent performance, unless you
-		/// intend to do write operations (delete documents or
-		/// change norms) with the reader.
-		/// </summary>
-		/// <param name="commit">the commit point to open
-		/// </param>
-		/// <param name="readOnly">true if no changes (deletions, norms) will be made with this IndexReader
-		/// </param>
-		/// <throws>  CorruptIndexException if the index is corrupt </throws>
-		/// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
-		public static IndexReader Open(IndexCommit commit, bool readOnly)
-		{
-			return Open(commit.Directory, null, commit, readOnly, DEFAULT_TERMS_INDEX_DIVISOR);
-		}
-		
-		/// <summary>Expert: returns an IndexReader reading the index in
-		/// the given Directory, with a custom <see cref="IndexDeletionPolicy" />
-		///.  You should pass readOnly=true,
-		/// since it gives much better concurrent performance,
-		/// unless you intend to do write operations (delete
-		/// documents or change norms) with the reader.
-		/// </summary>
-		/// <param name="directory">the index directory
-		/// </param>
-		/// <param name="deletionPolicy">a custom deletion policy (only used
-		/// if you use this reader to perform deletes or to set
-		/// norms); see <see cref="IndexWriter" /> for details.
-		/// </param>
-		/// <param name="readOnly">true if no changes (deletions, norms) will be made with this IndexReader
-		/// </param>
-		/// <throws>  CorruptIndexException if the index is corrupt </throws>
-		/// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
-		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, bool readOnly)
+        {
+            return Open(directory, null, null, readOnly, DEFAULT_TERMS_INDEX_DIVISOR);
+        }
+        
+        /// <summary>Expert: returns an IndexReader reading the index in the given
+        /// <see cref="IndexCommit" />.  You should pass readOnly=true, since it
+        /// gives much better concurrent performance, unless you
+        /// intend to do write operations (delete documents or
+        /// change norms) with the reader.
+        /// </summary>
+        /// <param name="commit">the commit point to open
+        /// </param>
+        /// <param name="readOnly">true if no changes (deletions, norms) will be made with this IndexReader
+        /// </param>
+        /// <throws>  CorruptIndexException if the index is corrupt </throws>
+        /// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
+        public static IndexReader Open(IndexCommit commit, bool readOnly)
+        {
+            return Open(commit.Directory, null, commit, readOnly, DEFAULT_TERMS_INDEX_DIVISOR);
+        }
+        
+        /// <summary>Expert: returns an IndexReader reading the index in
+        /// the given Directory, with a custom <see cref="IndexDeletionPolicy" />
+        ///.  You should pass readOnly=true,
+        /// since it gives much better concurrent performance,
+        /// unless you intend to do write operations (delete
+        /// documents or change norms) with the reader.
+        /// </summary>
+        /// <param name="directory">the index directory
+        /// </param>
+        /// <param name="deletionPolicy">a custom deletion policy (only used
+        /// if you use this reader to perform deletes or to set
+        /// norms); see <see cref="IndexWriter" /> for details.
+        /// </param>
+        /// <param name="readOnly">true if no changes (deletions, norms) will be made with this IndexReader
+        /// </param>
+        /// <throws>  CorruptIndexException if the index is corrupt </throws>
+        /// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
+        public static IndexReader Open(Directory directory, IndexDeletionPolicy deletionPolicy, bool readOnly)
+        {
+            return Open(directory, deletionPolicy, null, readOnly, DEFAULT_TERMS_INDEX_DIVISOR);
+        }
 
-		/// <summary>Expert: returns an IndexReader reading the index in
-		/// the given Directory, with a custom <see cref="IndexDeletionPolicy" />
-		///.  You should pass readOnly=true,
-		/// since it gives much better concurrent performance,
-		/// unless you intend to do write operations (delete
-		/// documents or change norms) with the reader.
-		/// </summary>
-		/// <param name="directory">the index directory
-		/// </param>
-		/// <param name="deletionPolicy">a custom deletion policy (only used
-		/// if you use this reader to perform deletes or to set
-		/// norms); see <see cref="IndexWriter" /> for details.
-		/// </param>
-		/// <param name="readOnly">true if no changes (deletions, norms) will be made with this IndexReader
-		/// </param>
-		/// <param name="termInfosIndexDivisor">Subsamples which indexed
-		/// terms are loaded into RAM. This has the same effect as <see>
-		///                                                          <cref>IndexWriter.SetTermIndexInterval</cref>
-		///                                                        </see> except that setting
-		/// must be done at indexing time while this setting can be
-		/// set per reader.  When set to N, then one in every
-		/// N*termIndexInterval terms in the index is loaded into
-		/// memory.  By setting this to a value > 1 you can reduce
-		/// memory usage, at the expense of higher latency when
-		/// loading a TermInfo.  The default value is 1.  Set this
-		/// to -1 to skip loading the terms index entirely.
-		/// </param>
-		/// <throws>  CorruptIndexException if the index is corrupt </throws>
-		/// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
-		public static IndexReader Open(Directory directory, IndexDeletionPolicy deletionPolicy, bool readOnly, int termInfosIndexDivisor)
-		{
-			return Open(directory, deletionPolicy, null, readOnly, termInfosIndexDivisor);
-		}
-		
-		/// <summary>Expert: returns an IndexReader reading the index in
-		/// the given Directory, using a specific commit and with
-		/// a custom <see cref="IndexDeletionPolicy" />.  You should pass
-		/// readOnly=true, since it gives much better concurrent
-		/// performance, unless you intend to do write operations
-		/// (delete documents or change norms) with the reader.
-		/// </summary>
-		/// <param name="commit">the specific <see cref="IndexCommit" /> to open;
-		/// see <see cref="IndexReader.ListCommits" /> to list all commits
-		/// in a directory
-		/// </param>
-		/// <param name="deletionPolicy">a custom deletion policy (only used
-		/// if you use this reader to perform deletes or to set
-		/// norms); see <see cref="IndexWriter" /> for details.
-		/// </param>
-		/// <param name="readOnly">true if no changes (deletions, norms) will be made with this IndexReader
-		/// </param>
-		/// <throws>  CorruptIndexException if the index is corrupt </throws>
-		/// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
-		public static IndexReader Open(IndexCommit commit, IndexDeletionPolicy deletionPolicy, bool readOnly)
-		{
-			return Open(commit.Directory, deletionPolicy, commit, readOnly, DEFAULT_TERMS_INDEX_DIVISOR);
-		}
+        /// <summary>Expert: returns an IndexReader reading the index in
+        /// the given Directory, with a custom <see cref="IndexDeletionPolicy" />
+        ///.  You should pass readOnly=true,
+        /// since it gives much better concurrent performance,
+        /// unless you intend to do write operations (delete
+        /// documents or change norms) with the reader.
+        /// </summary>
+        /// <param name="directory">the index directory
+        /// </param>
+        /// <param name="deletionPolicy">a custom deletion policy (only used
+        /// if you use this reader to perform deletes or to set
+        /// norms); see <see cref="IndexWriter" /> for details.
+        /// </param>
+        /// <param name="readOnly">true if no changes (deletions, norms) will be made with this IndexReader
+        /// </param>
+        /// <param name="termInfosIndexDivisor">Subsamples which indexed
+        /// terms are loaded into RAM. This has the same effect as <see>
+        ///                                                          <cref>IndexWriter.SetTermIndexInterval</cref>
+        ///                                                        </see> except that setting
+        /// must be done at indexing time while this setting can be
+        /// set per reader.  When set to N, then one in every
+        /// N*termIndexInterval terms in the index is loaded into
+        /// memory.  By setting this to a value > 1 you can reduce
+        /// memory usage, at the expense of higher latency when
+        /// loading a TermInfo.  The default value is 1.  Set this
+        /// to -1 to skip loading the terms index entirely.
+        /// </param>
+        /// <throws>  CorruptIndexException if the index is corrupt </throws>
+        /// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
+        public static IndexReader Open(Directory directory, IndexDeletionPolicy deletionPolicy, bool readOnly, int termInfosIndexDivisor)
+        {
+            return Open(directory, deletionPolicy, null, readOnly, termInfosIndexDivisor);
+        }
+        
+        /// <summary>Expert: returns an IndexReader reading the index in
+        /// the given Directory, using a specific commit and with
+        /// a custom <see cref="IndexDeletionPolicy" />.  You should pass
+        /// readOnly=true, since it gives much better concurrent
+        /// performance, unless you intend to do write operations
+        /// (delete documents or change norms) with the reader.
+        /// </summary>
+        /// <param name="commit">the specific <see cref="IndexCommit" /> to open;
+        /// see <see cref="IndexReader.ListCommits" /> to list all commits
+        /// in a directory
+        /// </param>
+        /// <param name="deletionPolicy">a custom deletion policy (only used
+        /// if you use this reader to perform deletes or to set
+        /// norms); see <see cref="IndexWriter" /> for details.
+        /// </param>
+        /// <param name="readOnly">true if no changes (deletions, norms) will be made with this IndexReader
+        /// </param>
+        /// <throws>  CorruptIndexException if the index is corrupt </throws>
+        /// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
+        public static IndexReader Open(IndexCommit commit, IndexDeletionPolicy deletionPolicy, bool readOnly)
+        {
+            return Open(commit.Directory, deletionPolicy, commit, readOnly, DEFAULT_TERMS_INDEX_DIVISOR);
+        }
 
-		/// <summary>Expert: returns an IndexReader reading the index in
-		/// the given Directory, using a specific commit and with
-		/// a custom <see cref="IndexDeletionPolicy" />.  You should pass
-		/// readOnly=true, since it gives much better concurrent
-		/// performance, unless you intend to do write operations
-		/// (delete documents or change norms) with the reader.
-		/// </summary>
-		/// <param name="commit">the specific <see cref="IndexCommit" /> to open;
-		/// see <see cref="IndexReader.ListCommits" /> to list all commits
-		/// in a directory
-		/// </param>
-		/// <param name="deletionPolicy">a custom deletion policy (only used
-		/// if you use this reader to perform deletes or to set
-		/// norms); see <see cref="IndexWriter" /> for details.
-		/// </param>
-		/// <param name="readOnly">true if no changes (deletions, norms) will be made with this IndexReader
-		/// </param>
-		/// <param name="termInfosIndexDivisor">Subsambles which indexed
-		/// terms are loaded into RAM. This has the same effect as <see>
-		///                                                          <cref>IndexWriter.SetTermIndexInterval</cref>
-		///                                                        </see> except that setting
-		/// must be done at indexing time while this setting can be
-		/// set per reader.  When set to N, then one in every
-		/// N*termIndexInterval terms in the index is loaded into
-		/// memory.  By setting this to a value > 1 you can reduce
-		/// memory usage, at the expense of higher latency when
-		/// loading a TermInfo.  The default value is 1.  Set this
-		/// to -1 to skip loading the terms index entirely.
-		/// </param>
-		/// <throws>  CorruptIndexException if the index is corrupt </throws>
-		/// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
-		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);
-		}
-		
-		/// <summary> Refreshes an IndexReader if the index has changed since this instance 
-		/// was (re)opened. 
-		/// <p/>
-		/// Opening an IndexReader is an expensive operation. This method can be used
-		/// to refresh an existing IndexReader to reduce these costs. This method 
-		/// tries to only load segments that have changed or were created after the 
-		/// IndexReader was (re)opened.
-		/// <p/>
-		/// If the index has not changed since this instance was (re)opened, then this
-		/// call is a NOOP and returns this instance. Otherwise, a new instance is 
-		/// returned. The old instance is <b>not</b> closed and remains usable.<br/>
-		/// <p/>   
-		/// If the reader is reopened, even though they share
-		/// resources internally, it's safe to make changes
-		/// (deletions, norms) with the new reader.  All shared
-		/// mutable state obeys "copy on write" semantics to ensure
-		/// the changes are not seen by other readers.
-		/// <p/>
-		/// You can determine whether a reader was actually reopened by comparing the
-		/// old instance with the instance returned by this method: 
+        /// <summary>Expert: returns an IndexReader reading the index in
+        /// the given Directory, using a specific commit and with
+        /// a custom <see cref="IndexDeletionPolicy" />.  You should pass
+        /// readOnly=true, since it gives much better concurrent
+        /// performance, unless you intend to do write operations
+        /// (delete documents or change norms) with the reader.
+        /// </summary>
+        /// <param name="commit">the specific <see cref="IndexCommit" /> to open;
+        /// see <see cref="IndexReader.ListCommits" /> to list all commits
+        /// in a directory
+        /// </param>
+        /// <param name="deletionPolicy">a custom deletion policy (only used
+        /// if you use this reader to perform deletes or to set
+        /// norms); see <see cref="IndexWriter" /> for details.
+        /// </param>
+        /// <param name="readOnly">true if no changes (deletions, norms) will be made with this IndexReader
+        /// </param>
+        /// <param name="termInfosIndexDivisor">Subsambles which indexed
+        /// terms are loaded into RAM. This has the same effect as <see>
+        ///                                                          <cref>IndexWriter.SetTermIndexInterval</cref>
+        ///                                                        </see> except that setting
+        /// must be done at indexing time while this setting can be
+        /// set per reader.  When set to N, then one in every
+        /// N*termIndexInterval terms in the index is loaded into
+        /// memory.  By setting this to a value > 1 you can reduce
+        /// memory usage, at the expense of higher latency when
+        /// loading a TermInfo.  The default value is 1.  Set this
+        /// to -1 to skip loading the terms index entirely.
+        /// </param>
+        /// <throws>  CorruptIndexException if the index is corrupt </throws>
+        /// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
+        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);
+        }
+        
+        /// <summary> Refreshes an IndexReader if the index has changed since this instance 
+        /// was (re)opened. 
+        /// <p/>
+        /// Opening an IndexReader is an expensive operation. This method can be used
+        /// to refresh an existing IndexReader to reduce these costs. This method 
+        /// tries to only load segments that have changed or were created after the 
+        /// IndexReader was (re)opened.
+        /// <p/>
+        /// If the index has not changed since this instance was (re)opened, then this
+        /// call is a NOOP and returns this instance. Otherwise, a new instance is 
+        /// returned. The old instance is <b>not</b> closed and remains usable.<br/>
+        /// <p/>   
+        /// If the reader is reopened, even though they share
+        /// resources internally, it's safe to make changes
+        /// (deletions, norms) with the new reader.  All shared
+        /// mutable state obeys "copy on write" semantics to ensure
+        /// the changes are not seen by other readers.
+        /// <p/>
+        /// You can determine whether a reader was actually reopened by comparing the
+        /// old instance with the instance returned by this method: 
         /// <code>
-		/// IndexReader reader = ... 
-		/// ...
-		/// IndexReader newReader = r.reopen();
-		/// if (newReader != reader) {
-		/// ...     // reader was reopened
-		/// reader.close(); 
-		/// }
-		/// reader = newReader;
-		/// ...
+        /// IndexReader reader = ... 
+        /// ...
+        /// IndexReader newReader = r.reopen();
+        /// if (newReader != reader) {
+        /// ...     // reader was reopened
+        /// reader.close(); 
+        /// }
+        /// reader = newReader;
+        /// ...
         /// </code>
-		/// 
-		/// Be sure to synchronize that code so that other threads,
-		/// if present, can never use reader after it has been
-		/// closed and before it's switched to newReader.
-		/// 
-		/// <p/><b>NOTE</b>: If this reader is a near real-time
-		/// reader (obtained from <see cref="IndexWriter.GetReader()" />,
-		/// reopen() will simply call writer.getReader() again for
-		/// you, though this may change in the future.
-		/// 
-		/// </summary>
-		/// <throws>  CorruptIndexException if the index is corrupt </throws>
-		/// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
-		public virtual IndexReader Reopen()
-		{
-			lock (this)
-			{
-				throw new NotSupportedException("This reader does not support reopen().");
-			}
-		}
-		
-		
-		/// <summary>Just like <see cref="Reopen()" />, except you can change the
-		/// readOnly of the original reader.  If the index is
-		/// unchanged but readOnly is different then a new reader
-		/// will be returned. 
-		/// </summary>
-		public virtual IndexReader Reopen(bool openReadOnly)
-		{
-			lock (this)
-			{
-				throw new NotSupportedException("This reader does not support reopen().");
-			}
-		}
-		
-		/// <summary>Expert: reopen this reader on a specific commit point.
-		/// This always returns a readOnly reader.  If the
-		/// specified commit point matches what this reader is
-		/// already on, and this reader is already readOnly, then
-		/// this same instance is returned; if it is not already
-		/// readOnly, a readOnly clone is returned. 
-		/// </summary>
-		public virtual IndexReader Reopen(IndexCommit commit)
-		{
-			lock (this)
-			{
-				throw new NotSupportedException("This reader does not support reopen(IndexCommit).");
-			}
-		}
-		
-		/// <summary> Efficiently clones the IndexReader (sharing most
-		/// internal state).
-		/// <p/>
-		/// On cloning a reader with pending changes (deletions,
-		/// norms), the original reader transfers its write lock to
-		/// the cloned reader.  This means only the cloned reader
-		/// may make further changes to the index, and commit the
-		/// changes to the index on close, but the old reader still
-		/// reflects all changes made up until it was cloned.
-		/// <p/>
-		/// Like <see cref="Reopen()" />, it's safe to make changes to
-		/// either the original or the cloned reader: all shared
-		/// mutable state obeys "copy on write" semantics to ensure
-		/// the changes are not seen by other readers.
-		/// <p/>
-		/// </summary>
-		/// <throws>  CorruptIndexException if the index is corrupt </throws>
-		/// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
-		public virtual System.Object Clone()
-		{
-			throw new System.NotSupportedException("This reader does not implement clone()");
-		}
-		
-		/// <summary> Clones the IndexReader and optionally changes readOnly.  A readOnly 
-		/// reader cannot open a writeable reader.  
-		/// </summary>
-		/// <throws>  CorruptIndexException if the index is corrupt </throws>
-		/// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
-		public virtual IndexReader Clone(bool openReadOnly)
-		{
-			lock (this)
-			{
-				throw new System.NotSupportedException("This reader does not implement clone()");
-			}
-		}
-		
-		/// <summary> Returns the directory associated with this index.  The Default 
-		/// implementation returns the directory specified by subclasses when 
-		/// delegating to the IndexReader(Directory) constructor, or throws an 
-		/// UnsupportedOperationException if one was not specified.
-		/// </summary>
-		/// <throws>  UnsupportedOperationException if no directory </throws>
-		public virtual Directory Directory()
-		{
-			EnsureOpen();
+        /// 
+        /// Be sure to synchronize that code so that other threads,
+        /// if present, can never use reader after it has been
+        /// closed and before it's switched to newReader.
+        /// 
+        /// <p/><b>NOTE</b>: If this reader is a near real-time
+        /// reader (obtained from <see cref="IndexWriter.GetReader()" />,
+        /// reopen() will simply call writer.getReader() again for
+        /// you, though this may change in the future.
+        /// 
+        /// </summary>
+        /// <throws>  CorruptIndexException if the index is corrupt </throws>
+        /// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
+        public virtual IndexReader Reopen()
+        {
+            lock (this)
+            {
+                throw new NotSupportedException("This reader does not support reopen().");
+            }
+        }
+        
+        
+        /// <summary>Just like <see cref="Reopen()" />, except you can change the
+        /// readOnly of the original reader.  If the index is
+        /// unchanged but readOnly is different then a new reader
+        /// will be returned. 
+        /// </summary>
+        public virtual IndexReader Reopen(bool openReadOnly)
+        {
+            lock (this)
+            {
+                throw new NotSupportedException("This reader does not support reopen().");
+            }
+        }
+        
+        /// <summary>Expert: reopen this reader on a specific commit point.
+        /// This always returns a readOnly reader.  If the
+        /// specified commit point matches what this reader is
+        /// already on, and this reader is already readOnly, then
+        /// this same instance is returned; if it is not already
+        /// readOnly, a readOnly clone is returned. 
+        /// </summary>
+        public virtual IndexReader Reopen(IndexCommit commit)
+        {
+            lock (this)
+            {
+                throw new NotSupportedException("This reader does not support reopen(IndexCommit).");
+            }
+        }
+        
+        /// <summary> Efficiently clones the IndexReader (sharing most
+        /// internal state).
+        /// <p/>
+        /// On cloning a reader with pending changes (deletions,
+        /// norms), the original reader transfers its write lock to
+        /// the cloned reader.  This means only the cloned reader
+        /// may make further changes to the index, and commit the
+        /// changes to the index on close, but the old reader still
+        /// reflects all changes made up until it was cloned.
+        /// <p/>
+        /// Like <see cref="Reopen()" />, it's safe to make changes to
+        /// either the original or the cloned reader: all shared
+        /// mutable state obeys "copy on write" semantics to ensure
+        /// the changes are not seen by other readers.
+        /// <p/>
+        /// </summary>
+        /// <throws>  CorruptIndexException if the index is corrupt </throws>
+        /// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
+        public virtual System.Object Clone()
+        {
+            throw new System.NotSupportedException("This reader does not implement clone()");
+        }
+        
+        /// <summary> Clones the IndexReader and optionally changes readOnly.  A readOnly 
+        /// reader cannot open a writeable reader.  
+        /// </summary>
+        /// <throws>  CorruptIndexException if the index is corrupt </throws>
+        /// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
+        public virtual IndexReader Clone(bool openReadOnly)
+        {
+            lock (this)
+            {
+                throw new System.NotSupportedException("This reader does not implement clone()");
+            }
+        }
+        
+        /// <summary> Returns the directory associated with this index.  The Default 
+        /// implementation returns the directory specified by subclasses when 
+        /// delegating to the IndexReader(Directory) constructor, or throws an 
+        /// UnsupportedOperationException if one was not specified.
+        /// </summary>
+        /// <throws>  UnsupportedOperationException if no directory </throws>
+        public virtual Directory Directory()
+        {
+            EnsureOpen();
             throw new NotSupportedException("This reader does not support this method.");
-		}
-		
-		/// <summary> Returns the time the index in the named directory was last modified. 
-		/// Do not use this to check whether the reader is still up-to-date, use
-		/// <see cref="IsCurrent()" /> instead. 
-		/// </summary>
-		/// <throws>  CorruptIndexException if the index is corrupt </throws>
-		/// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
-		public static long LastModified(Directory directory2)
-		{
-			return (long) ((System.Int64) new AnonymousClassFindSegmentsFile(directory2, directory2).Run());
-		}
-		
-		/// <summary> Reads version number from segments files. The version number is
-		/// initialized with a timestamp and then increased by one for each change of
-		/// the index.
-		/// 
-		/// </summary>
-		/// <param name="directory">where the index resides.
-		/// </param>
-		/// <returns> version number.
-		/// </returns>
-		/// <throws>  CorruptIndexException if the index is corrupt </throws>
-		/// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
-		public static long GetCurrentVersion(Directory directory)
-		{
-			return SegmentInfos.ReadCurrentVersion(directory);
-		}
+        }
+        
+        /// <summary> Returns the time the index in the named directory was last modified. 
+        /// Do not use this to check whether the reader is still up-to-date, use
+        /// <see cref="IsCurrent()" /> instead. 
+        /// </summary>
+        /// <throws>  CorruptIndexException if the index is corrupt </throws>
+        /// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
+        public static long LastModified(Directory directory2)
+        {
+            return (long) ((System.Int64) new AnonymousClassFindSegmentsFile(directory2, directory2).Run());
+        }
+        
+        /// <summary> Reads version number from segments files. The version number is
+        /// initialized with a timestamp and then increased by one for each change of
+        /// the index.
+        /// 
+        /// </summary>
+        /// <param name="directory">where the index resides.
+        /// </param>
+        /// <returns> version number.
+        /// </returns>
+        /// <throws>  CorruptIndexException if the index is corrupt </throws>
+        /// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
+        public static long GetCurrentVersion(Directory directory)
+        {
+            return SegmentInfos.ReadCurrentVersion(directory);
+        }
 
         /// <summary> Reads commitUserData, previously passed to 
         /// <see cref="IndexWriter.Commit(System.Collections.Generic.IDictionary{string, string})" />,
-		/// from current index segments file.  This will return null if 
+        /// from current index segments file.  This will return null if 
         /// <see cref="IndexWriter.Commit(System.Collections.Generic.IDictionary{string, string})" />
-		/// has never been called for this index.
-		/// </summary>
-		/// <param name="directory">where the index resides.
-		/// </param>
-		/// <returns> commit userData.
-		/// </returns>
-		/// <throws>  CorruptIndexException if the index is corrupt </throws>
-		/// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
-		/// <summary> 
-		/// </summary>
-		/// <seealso cref="GetCommitUserData(Store.Directory)">
-		/// </seealso>
+        /// has never been called for this index.
+        /// </summary>
+        /// <param name="directory">where the index resides.
+        /// </param>
+        /// <returns> commit userData.
+        /// </returns>
+        /// <throws>  CorruptIndexException if the index is corrupt </throws>
+        /// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
+        /// <summary> 
+        /// </summary>
+        /// <seealso cref="GetCommitUserData(Store.Directory)">
+        /// </seealso>
         public static System.Collections.Generic.IDictionary<string, string> GetCommitUserData(Directory directory)
-		{
-			return SegmentInfos.ReadCurrentUserData(directory);
-		}
+        {
+            return SegmentInfos.ReadCurrentUserData(directory);
+        }
 
-	    /// <summary> Version number when this IndexReader was opened. Not implemented in the
-	    /// IndexReader base class.
-	    /// 
-	    /// <p/>
-	    /// If this reader is based on a Directory (ie, was created by calling
-	    /// <see cref="Open(Lucene.Net.Store.Directory, bool)" />, or <see cref="Reopen()" /> 
-	    /// on a reader based on a Directory), then
-	    /// this method returns the version recorded in the commit that the reader
-	    /// opened. This version is advanced every time <see cref="IndexWriter.Commit()" /> is
-	    /// called.
-	    /// <p/>
-	    /// 
-	    /// <p/>
-	    /// If instead this reader is a near real-time reader (ie, obtained by a call
-	    /// to <see cref="IndexWriter.GetReader()" />, or by calling <see cref="Reopen()" /> on a near
-	    /// real-time reader), then this method returns the version of the last
-	    /// commit done by the writer. Note that even as further changes are made
-	    /// with the writer, the version will not changed until a commit is
-	    /// completed. Thus, you should not rely on this method to determine when a
-	    /// near real-time reader should be opened. Use <see cref="IsCurrent" /> instead.
-	    /// <p/>
-	    /// 
-	    /// </summary>
-	    /// <throws>  UnsupportedOperationException </throws>
-	    /// <summary>             unless overridden in subclass
-	    /// </summary>
-	    public virtual long Version
-	    {
-	        get { throw new System.NotSupportedException("This reader does not support this method."); }
-	    }
+        /// <summary> Version number when this IndexReader was opened. Not implemented in the
+        /// IndexReader base class.
+        /// 
+        /// <p/>
+        /// If this reader is based on a Directory (ie, was created by calling
+        /// <see cref="Open(Lucene.Net.Store.Directory, bool)" />, or <see cref="Reopen()" /> 
+        /// on a reader based on a Directory), then
+        /// this method returns the version recorded in the commit that the reader
+        /// opened. This version is advanced every time <see cref="IndexWriter.Commit()" /> is
+        /// called.
+        /// <p/>
+        /// 
+        /// <p/>
+        /// If instead this reader is a near real-time reader (ie, obtained by a call
+        /// to <see cref="IndexWriter.GetReader()" />, or by calling <see cref="Reopen()" /> on a near
+        /// real-time reader), then this method returns the version of the last
+        /// commit done by the writer. Note that even as further changes are made
+        /// with the writer, the version will not changed until a commit is
+        /// completed. Thus, you should not rely on this method to determine when a
+        /// near real-time reader should be opened. Use <see cref="IsCurrent" /> instead.
+        /// <p/>
+        /// 
+        /// </summary>
+        /// <throws>  UnsupportedOperationException </throws>
+        /// <summary>             unless overridden in subclass
+        /// </summary>
+        public virtual long Version
+        {
+            get { throw new System.NotSupportedException("This reader does not support this method."); }
+        }
 
-	    /// <summary> Retrieve the String userData optionally passed to
-	    /// <see cref="IndexWriter.Commit(System.Collections.Generic.IDictionary{string, string})" />.  
-	    /// This will return null if 
-	    /// <see cref="IndexWriter.Commit(System.Collections.Generic.IDictionary{string, string})" />
-	    /// has never been called for this index.
-	    /// </summary>
-	    /// <seealso cref="GetCommitUserData(Store.Directory)">
-	    /// </seealso>
-	    public virtual IDictionary<string, string> CommitUserData
-	    {
-	        get { throw new System.NotSupportedException("This reader does not support this method."); }
-	    }
+        /// <summary> Retrieve the String userData optionally passed to
+        /// <see cref="IndexWriter.Commit(System.Collections.Generic.IDictionary{string, string})" />.  
+        /// This will return null if 
+        /// <see cref="IndexWriter.Commit(System.Collections.Generic.IDictionary{string, string})" />
+        /// has never been called for this index.
+        /// </summary>
+        /// <seealso cref="GetCommitUserData(Store.Directory)">
+        /// </seealso>
+        public virtual IDictionary<string, string> CommitUserData
+        {
+            get { throw new System.NotSupportedException("This reader does not support this method."); }
+        }
 
-		/// <summary> Check whether any new changes have occurred to the index since this
-		/// reader was opened.
-		/// 
-		/// <p/>
-		/// If this reader is based on a Directory (ie, was created by calling
-		/// <see>
-		///   <cref>Open(Store.Directory)</cref>
-		/// </see> , or <see cref="Reopen()" /> on a reader based on a Directory), then
-		/// this method checks if any further commits (see <see cref="IndexWriter.Commit()" />
-		/// have occurred in that directory).
-		/// <p/>
-		/// 
-		/// <p/>
-		/// If instead this reader is a near real-time reader (ie, obtained by a call
-		/// to <see cref="IndexWriter.GetReader()" />, or by calling <see cref="Reopen()" /> on a near
-		/// real-time reader), then this method checks if either a new commmit has
-		/// occurred, or any new uncommitted changes have taken place via the writer.
-		/// Note that even if the writer has only performed merging, this method will
-		/// still return false.
-		/// <p/>
-		/// 
-		/// <p/>
-		/// In any event, if this returns false, you should call <see cref="Reopen()" /> to
-		/// get a new reader that sees the changes.
-		/// <p/>
-		/// 
-		/// </summary>
-		/// <throws>  CorruptIndexException if the index is corrupt </throws>
-		/// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
-		/// <throws>  UnsupportedOperationException unless overridden in subclass </throws>
-		public virtual bool IsCurrent()
-	    {
-	        throw new NotSupportedException("This reader does not support this method.");
-	    }
+        /// <summary> Check whether any new changes have occurred to the index since this
+        /// reader was opened.
+        /// 
+        /// <p/>
+        /// If this reader is based on a Directory (ie, was created by calling
+        /// <see>
+        ///   <cref>Open(Store.Directory)</cref>
+        /// </see> , or <see cref="Reopen()" /> on a reader based on a Directory), then
+        /// this method checks if any further commits (see <see cref="IndexWriter.Commit()" />
+        /// have occurred in that directory).
+        /// <p/>
+        /// 
+        /// <p/>
+        /// If instead this reader is a near real-time reader (ie, obtained by a call
+        /// to <see cref="IndexWriter.GetReader()" />, or by calling <see cref="Reopen()" /> on a near
+        /// real-time reader), then this method checks if either a new commmit has
+        /// occurred, or any new uncommitted changes have taken place via the writer.
+        /// Note that even if the writer has only performed merging, this method will
+        /// still return false.
+        /// <p/>
+        /// 
+        /// <p/>
+        /// In any event, if this returns false, you should call <see cref="Reopen()" /> to
+        /// get a new reader that sees the changes.
+        /// <p/>
+        /// 
+        /// </summary>
+        /// <throws>  CorruptIndexException if the index is corrupt </throws>
+        /// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
+        /// <throws>  UnsupportedOperationException unless overridden in subclass </throws>
+        public virtual bool IsCurrent()
+        {
+            throw new NotSupportedException("This reader does not support this method.");
+        }
 
-	    /// <summary> Checks is the index is optimized (if it has a single segment and 
-	    /// no deletions).  Not implemented in the IndexReader base class.
-	    /// </summary>
-	    /// <returns> &amp;lt;c&amp;gt;true&amp;lt;/c&amp;gt; if the index is optimized; &amp;lt;c&amp;gt;false&amp;lt;/c&amp;gt; otherwise </returns>
-	    /// <throws>  UnsupportedOperationException unless overridden in subclass </throws>
-	    public virtual bool IsOptimized()
-	    {
-	        throw new NotSupportedException("This reader does not support this method.");
-	    }
+        /// <summary> Checks is the index is optimized (if it has a single segment and 
+        /// no deletions).  Not implemented in the IndexReader base class.
+        /// </summary>
+        /// <returns> &amp;lt;c&amp;gt;true&amp;lt;/c&amp;gt; if the index is optimized; &amp;lt;c&amp;gt;false&amp;lt;/c&amp;gt; otherwise </returns>
+        /// <throws>  UnsupportedOperationException unless overridden in subclass </throws>
+        public virtual bool IsOptimized()
+        {
+            throw new NotSupportedException("This reader does not support this method.");
+        }
 
-	    /// <summary> Return an array of term frequency vectors for the specified document.
-		/// The array contains a vector for each vectorized field in the document.
-		/// Each vector contains terms and frequencies for all terms in a given vectorized field.
-		/// If no such fields existed, the method returns null. The term vectors that are
-		/// returned may either be of type <see cref="ITermFreqVector" />
-		/// or of type <see cref="TermPositionVector" /> if
-		/// positions or offsets have been stored.
-		/// 
-		/// </summary>
-		/// <param name="docNumber">document for which term frequency vectors are returned
-		/// </param>
-		/// <returns> array of term frequency vectors. May be null if no term vectors have been
-		/// stored for the specified document.
-		/// </returns>
-		/// <throws>  IOException if index cannot be accessed </throws>
-		/// <seealso cref="Lucene.Net.Documents.Field.TermVector">
-		/// </seealso>
-		abstract public ITermFreqVector[] GetTermFreqVectors(int docNumber);
-		
-		
-		/// <summary> Return a term frequency vector for the specified document and field. The
-		/// returned vector contains terms and frequencies for the terms in
-		/// the specified field of this document, if the field had the storeTermVector
-		/// flag set. If termvectors had been stored with positions or offsets, a 
-		/// <see cref="TermPositionVector" /> is returned.
-		/// 
-		/// </summary>
-		/// <param name="docNumber">document for which the term frequency vector is returned
-		/// </param>
-		/// <param name="field">field for which the term frequency vector is returned.
-		/// </param>
-		/// <returns> term frequency vector May be null if field does not exist in the specified
-		/// document or term vector was not stored.
-		/// </returns>
-		/// <throws>  IOException if index cannot be accessed </throws>
-		/// <seealso cref="Lucene.Net.Documents.Field.TermVector">
-		/// </seealso>
-		abstract public ITermFreqVector GetTermFreqVector(int docNumber, String field);
-		
-		/// <summary> Load the Term Vector into a user-defined data structure instead of relying on the parallel arrays of
-		/// the <see cref="ITermFreqVector" />.
-		/// </summary>
-		/// <param name="docNumber">The number of the document to load the vector for
-		/// </param>
-		/// <param name="field">The name of the field to load
-		/// </param>
-		/// <param name="mapper">The <see cref="TermVectorMapper" /> to process the vector.  Must not be null
-		/// </param>
-		/// <throws>  IOException if term vectors cannot be accessed or if they do not exist on the field and doc. specified. </throws>
-		/// <summary> 
-		/// </summary>
-		abstract public void  GetTermFreqVector(int docNumber, String field, TermVectorMapper mapper);
-		
-		/// <summary> Map all the term vectors for all fields in a Document</summary>
-		/// <param name="docNumber">The number of the document to load the vector for
-		/// </param>
-		/// <param name="mapper">The <see cref="TermVectorMapper" /> to process the vector.  Must not be null
-		/// </param>
-		/// <throws>  IOException if term vectors cannot be accessed or if they do not exist on the field and doc. specified. </throws>
-		abstract public void  GetTermFreqVector(int docNumber, TermVectorMapper mapper);
-		
-		/// <summary> Returns <c>true</c> if an index exists at the specified directory.
-		/// If the directory does not exist or if there is no index in it.
-		/// </summary>
-		/// <param name="directory">the directory to check for an index
-		/// </param>
-		/// <returns> <c>true</c> if an index exists; <c>false</c> otherwise
-		/// </returns>
-		/// <throws>  IOException if there is a problem with accessing the index </throws>
-		public static bool IndexExists(Directory directory)
-		{
-			return SegmentInfos.GetCurrentSegmentGeneration(directory) != - 1;
-		}
+        /// <summary> Return an array of term frequency vectors for the specified document.
+        /// The array contains a vector for each vectorized field in the document.
+        /// Each vector contains terms and frequencies for all terms in a given vectorized field.
+        /// If no such fields existed, the method returns null. The term vectors that are
+        /// returned may either be of type <see cref="ITermFreqVector" />
+        /// or of type <see cref="TermPositionVector" /> if
+        /// positions or offsets have been stored.
+        /// 
+        /// </summary>
+        /// <param name="docNumber">document for which term frequency vectors are returned
+        /// </param>
+        /// <returns> array of term frequency vectors. May be null if no term vectors have been
+        /// stored for the specified document.
+        /// </returns>
+        /// <throws>  IOException if index cannot be accessed </throws>
+        /// <seealso cref="Lucene.Net.Documents.Field.TermVector">
+        /// </seealso>
+        abstract public ITermFreqVector[] GetTermFreqVectors(int docNumber);
+        
+        
+        /// <summary> Return a term frequency vector for the specified document and field. The
+        /// returned vector contains terms and frequencies for the terms in
+        /// the specified field of this document, if the field had the storeTermVector
+        /// flag set. If termvectors had been stored with positions or offsets, a 
+        /// <see cref="TermPositionVector" /> is returned.
+        /// 
+        /// </summary>
+        /// <param name="docNumber">document for which the term frequency vector is returned
+        /// </param>
+        /// <param name="field">field for which the term frequency vector is returned.
+        /// </param>
+        /// <returns> term frequency vector May be null if field does not exist in the specified
+        /// document or term vector was not stored.
+        /// </returns>
+        /// <throws>  IOException if index cannot be accessed </throws>
+        /// <seealso cref="Lucene.Net.Documents.Field.TermVector">
+        /// </seealso>
+        abstract public ITermFreqVector GetTermFreqVector(int docNumber, String field);
+        
+        /// <summary> Load the Term Vector into a user-defined data structure instead of relying on the parallel arrays of
+        /// the <see cref="ITermFreqVector" />.
+        /// </summary>
+        /// <param name="docNumber">The number of the document to load the vector for
+        /// </param>
+        /// <param name="field">The name of the field to load
+        /// </param>
+        /// <param name="mapper">The <see cref="TermVectorMapper" /> to process the vector.  Must not be null
+        /// </param>
+        /// <throws>  IOException if term vectors cannot be accessed or if they do not exist on the field and doc. specified. </throws>
+        /// <summary> 
+        /// </summary>
+        abstract public void  GetTermFreqVector(int docNumber, String field, TermVectorMapper mapper);
+        
+        /// <summary> Map all the term vectors for all fields in a Document</summary>
+        /// <param name="docNumber">The number of the document to load the vector for
+        /// </param>
+        /// <param name="mapper">The <see cref="TermVectorMapper" /> to process the vector.  Must not be null
+        /// </param>
+        /// <throws>  IOException if term vectors cannot be accessed or if they do not exist on the field and doc. specified. </throws>
+        abstract public void  GetTermFreqVector(int docNumber, TermVectorMapper mapper);
+        
+        /// <summary> Returns <c>true</c> if an index exists at the specified directory.
+        /// If the directory does not exist or if there is no index in it.
+        /// </summary>
+        /// <param name="directory">the directory to check for an index
+        /// </param>
+        /// <returns> <c>true</c> if an index exists; <c>false</c> otherwise
+        /// </returns>
+        /// <throws>  IOException if there is a problem with accessing the index </throws>
+        public static bool IndexExists(Directory directory)
+        {
+            return SegmentInfos.GetCurrentSegmentGeneration(directory) != - 1;
+        }
 
-	    /// <summary>Returns the number of documents in this index. </summary>
+        /// <summary>Returns the number of documents in this index. </summary>
         [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate")]
         public abstract int NumDocs();
 
-	    /// <summary>Returns one greater than the largest possible document number.
-	    /// This may be used to, e.g., determine how big to allocate an array which
-	    /// will have an element for every document number in an index.
-	    /// </summary>
-	    public abstract int MaxDoc { get; }
+        /// <summary>Returns one greater than the largest possible document number.
+        /// This may be used to, e.g., determine how big to allocate an array which
+        /// will have an element for every document number in an index.
+        /// </summary>
+        public abstract int MaxDoc { get; }
 
-	    /// <summary>Returns the number of deleted documents. </summary>
-	    public virtual int NumDeletedDocs
-	    {
-	        get { return MaxDoc - NumDocs(); }
-	    }
+        /// <summary>Returns the number of deleted documents. </summary>
+        public virtual int NumDeletedDocs
+        {
+            get { return MaxDoc - NumDocs(); }
+        }
 
-	    /// <summary> Returns the stored fields of the <c>n</c><sup>th</sup>
-		/// <c>Document</c> in this index.
-		/// <p/>
-		/// <b>NOTE:</b> for performance reasons, this method does not check if the
-		/// requested document is deleted, and therefore asking for a deleted document
-		/// may yield unspecified results. Usually this is not required, however you
-		/// can call <see cref="IsDeleted(int)" /> with the requested document ID to verify
-		/// the document is not deleted.
-		/// 
-		/// </summary>
-		/// <throws>  CorruptIndexException if the index is corrupt </throws>
-		/// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
-		public virtual Document Document(int n)
-		{
-			EnsureOpen();
-			return Document(n, null);
-		}
+        /// <summary> Returns the stored fields of the <c>n</c><sup>th</sup>
+        /// <c>Document</c> in this index.
+        /// <p/>
+        /// <b>NOTE:</b> for performance reasons, this method does not check if the
+        /// requested document is deleted, and therefore asking for a deleted document
+        /// may yield unspecified results. Usually this is not required, however you
+        /// can call <see cref="IsDeleted(int)" /> with the requested document ID to verify
+        /// the document is not deleted.
+        /// 
+        /// </summary>
+        /// <throws>  CorruptIndexException if the index is corrupt </throws>
+        /// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
+        public virtual Document Document(int n)
+        {
+            EnsureOpen();
+            return Document(n, null);
+        }
 
         /// <summary> Returns the stored fields of the <c>n</c><sup>th</sup>
         /// <c>Document</c> in this index.
@@ -744,119 +744,119 @@ namespace Lucene.Net.Index
         /// </summary>
         /// <throws>  CorruptIndexException if the index is corrupt </throws>
         /// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
-	    public Document this[int doc]
-	    {
-	        get { return Document(doc); }
-	    }
-		
-		/// <summary> Get the <see cref="Lucene.Net.Documents.Document" /> at the <c>n</c>
-		/// <sup>th</sup> position. The <see cref="FieldSelector" /> may be used to determine
-		/// what <see cref="Lucene.Net.Documents.Field" />s to load and how they should
-		/// be loaded. <b>NOTE:</b> If this Reader (more specifically, the underlying
-		/// <c>FieldsReader</c>) is closed before the lazy
-		/// <see cref="Lucene.Net.Documents.Field" /> is loaded an exception may be
-		/// thrown. If you want the value of a lazy
-		/// <see cref="Lucene.Net.Documents.Field" /> to be available after closing you
-		/// must explicitly load it or fetch the Document again with a new loader.
-		/// <p/>
-		/// <b>NOTE:</b> for performance reasons, this method does not check if the
-		/// requested document is deleted, and therefore asking for a deleted document
-		/// may yield unspecified results. Usually this is not required, however you
-		/// can call <see cref="IsDeleted(int)" /> with the requested document ID to verify
-		/// the document is not deleted.
-		/// 
-		/// </summary>
-		/// <param name="n">Get the document at the <c>n</c><sup>th</sup> position
-		/// </param>
-		/// <param name="fieldSelector">The <see cref="FieldSelector" /> to use to determine what
-		/// Fields should be loaded on the Document. May be null, in which case
-		/// all Fields will be loaded.
-		/// </param>
-		/// <returns> The stored fields of the
-		/// <see cref="Lucene.Net.Documents.Document" /> at the nth position
-		/// </returns>
-		/// <throws>  CorruptIndexException if the index is corrupt </throws>
-		/// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
-		/// <seealso cref="IFieldable">
-		/// </seealso>
-		/// <seealso cref="Lucene.Net.Documents.FieldSelector">
-		/// </seealso>
-		/// <seealso cref="Lucene.Net.Documents.SetBasedFieldSelector">
-		/// </seealso>
-		/// <seealso cref="Lucene.Net.Documents.LoadFirstFieldSelector">
-		/// </seealso>
-		// TODO (1.5): When we convert to JDK 1.5 make this Set<String>
-		public abstract Document Document(int n, FieldSelector fieldSelector);
-		
-		/// <summary>Returns true if document <i>n</i> has been deleted </summary>
-		public abstract bool IsDeleted(int n);
+        public Document this[int doc]
+        {
+            get { return Document(doc); }
+        }
+        
+        /// <summary> Get the <see cref="Lucene.Net.Documents.Document" /> at the <c>n</c>
+        /// <sup>th</sup> position. The <see cref="FieldSelector" /> may be used to determine
+        /// what <see cref="Lucene.Net.Documents.Field" />s to load and how they should
+        /// be loaded. <b>NOTE:</b> If this Reader (more specifically, the underlying
+        /// <c>FieldsReader</c>) is closed before the lazy
+        /// <see cref="Lucene.Net.Documents.Field" /> is loaded an exception may be
+        /// thrown. If you want the value of a lazy
+        /// <see cref="Lucene.Net.Documents.Field" /> to be available after closing you
+        /// must explicitly load it or fetch the Document again with a new loader.
+        /// <p/>
+        /// <b>NOTE:</b> for performance reasons, this method does not check if the
+        /// requested document is deleted, and therefore asking for a deleted document
+        /// may yield unspecified results. Usually this is not required, however you
+        /// can call <see cref="IsDeleted(int)" /> with the requested document ID to verify
+        /// the document is not deleted.
+        /// 
+        /// </summary>
+        /// <param name="n">Get the document at the <c>n</c><sup>th</sup> position
+        /// </param>
+        /// <param name="fieldSelector">The <see cref="FieldSelector" /> to use to determine what
+        /// Fields should be loaded on the Document. May be null, in which case
+        /// all Fields will be loaded.
+        /// </param>
+        /// <returns> The stored fields of the
+        /// <see cref="Lucene.Net.Documents.Document" /> at the nth position
+        /// </returns>
+        /// <throws>  CorruptIndexException if the index is corrupt </throws>
+        /// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
+        /// <seealso cref="IFieldable">
+        /// </seealso>
+        /// <seealso cref="Lucene.Net.Documents.FieldSelector">
+        /// </seealso>
+        /// <seealso cref="Lucene.Net.Documents.SetBasedFieldSelector">
+        /// </seealso>
+        /// <seealso cref="Lucene.Net.Documents.LoadFirstFieldSelector">
+        /// </seealso>
+        // TODO (1.5): When we convert to JDK 1.5 make this Set<String>
+        public abstract Document Document(int n, FieldSelector fieldSelector);
+        
+        /// <summary>Returns true if document <i>n</i> has been deleted </summary>
+        public abstract bool IsDeleted(int n);
 
-	    /// <summary>Returns true if any documents have been deleted </summary>
-	    public abstract bool HasDeletions { get; }
+        /// <summary>Returns true if any documents have been deleted </summary>
+        public abstract bool HasDeletions { get; }
 
-	    /// <summary>Returns true if there are norms stored for this field. </summary>
-		public virtual bool HasNorms(System.String field)
-		{
-			// backward compatible implementation.
-			// SegmentReader has an efficient implementation.
-			EnsureOpen();
-			return Norms(field) != null;
-		}
+        /// <summary>Returns true if there are norms stored for this field. </summary>
+        public virtual bool HasNorms(System.String field)
+        {
+            // backward compatible implementation.
+            // SegmentReader has an efficient implementation.
+            EnsureOpen();
+            return Norms(field) != null;
+        }
 
-		/// <summary>
-		/// Returns the byte-encoded normalization factor for the named field of
-		/// every document.  This is used by the search code to score documents.
-		/// </summary>
+        /// <summary>
+        /// Returns the byte-encoded normalization factor for the named field of
+        /// every document.  This is used by the search code to score documents.
+        /// </summary>
+        /// <seealso cref="Lucene.Net.Documents.AbstractField.Boost" />
+        public abstract byte[] Norms(System.String field);
+        
+        /// <summary>
+        /// Reads the byte-encoded normalization factor for the named field of every
+        /// document.  This is used by the search code to score documents.
+        /// </summary>
         /// <seealso cref="Lucene.Net.Documents.AbstractField.Boost" />
-		public abstract byte[] Norms(System.String field);
-		
-		/// <summary>
-		/// Reads the byte-encoded normalization factor for the named field of every
-		/// document.  This is used by the search code to score documents.
-		/// </summary>
-		/// <seealso cref="Lucene.Net.Documents.AbstractField.Boost" />
-		public abstract void  Norms(System.String field, byte[] bytes, int offset);
-		
-		/// <summary>Expert: Resets the normalization factor for the named field of the named
-		/// document.  The norm represents the product of the field's <see cref="IFieldable.Boost">boost</see>
+        public abstract void  Norms(System.String field, byte[] bytes, int offset);
+        
+        /// <summary>Expert: Resets the normalization factor for the named field of the named
+        /// document.  The norm represents the product of the field's <see cref="IFieldable.Boost">boost</see>
         /// and its <see cref="Similarity.LengthNorm(String,int)">length normalization</see>.  Thus, to preserve the length normalization
-		/// values when resetting this, one should base the new value upon the old.
-		/// 
-		/// <b>NOTE:</b> If this field does not store norms, then
-		/// this method call will silently do nothing.
-		/// </summary>
-		/// <seealso cref="Norms(String)" />
-		/// <seealso cref="Similarity.DecodeNorm(byte)" />
-		/// <exception cref="StaleReaderException">
+        /// values when resetting this, one should base the new value upon the old.
+        /// 
+        /// <b>NOTE:</b> If this field does not store norms, then
+        /// this method call will silently do nothing.
+        /// </summary>
+        /// <seealso cref="Norms(String)" />
+        /// <seealso cref="Similarity.DecodeNorm(byte)" />
+        /// <exception cref="StaleReaderException">
         /// If the index has changed since this reader was opened
-		/// </exception>
+        /// </exception>
         /// <exception cref="CorruptIndexException">
         /// If the index is corrupt
-		/// </exception>
-		/// <exception cref="LockObtainFailedException">
+        /// </exception>
+        /// <exception cref="LockObtainFailedException">
         /// If another writer has this index open (<c>write.lock</c> could not be obtained)
-		/// </exception>
-		/// <exception cref="System.IO.IOException">
+        /// </exception>
+        /// <exception cref="System.IO.IOException">
         /// If there is a low-level IO error
-		/// </exception>
-		public virtual void  SetNorm(int doc, String field, byte value)
-		{
-			lock (this)
-			{
-				EnsureOpen();
-				AcquireWriteLock();
-				hasChanges = true;
-				DoSetNorm(doc, field, value);
-			}
-		}
-		
-		/// <summary>Implements setNorm in subclass.</summary>
-		protected internal abstract void  DoSetNorm(int doc, System.String field, byte value_Renamed);
-		
-		/// <summary>
-		/// Expert: Resets the normalization factor for the named field of the named document.
-		/// </summary>
-		/// <seealso cref="Norms(String)" />
+        /// </exception>
+        public virtual void  SetNorm(int doc, String field, byte value)
+        {
+            lock (this)
+            {
+                EnsureOpen();
+                AcquireWriteLock();
+                hasChanges = true;
+                DoSetNorm(doc, field, value);
+            }
+        }
+        
+        /// <summary>Implements setNorm in subclass.</summary>
+        protected internal abstract void  DoSetNorm(int doc, System.String field, byte value_Renamed);
+        
+        /// <summary>
+        /// Expert: Resets the normalization factor for the named field of the named document.
+        /// </summary>
+        /// <seealso cref="Norms(String)" />
         /// <seealso cref="Similarity.DecodeNorm(byte)" />
         /// <exception cref="StaleReaderException">
         /// If the index has changed since this reader was opened
@@ -870,139 +870,139 @@ namespace Lucene.Net.Index
         /// <exception cref="System.IO.IOException">
         /// If there is a low-level IO error
         /// </exception>
-		public virtual void  SetNorm(int doc, System.String field, float value)
-		{
-			EnsureOpen();
-			SetNorm(doc, field, Similarity.EncodeNorm(value));
-		}
-		
-		/// <summary>Returns an enumeration of all the terms in the index. The
-		/// enumeration is ordered by Term.compareTo(). Each term is greater
-		/// than all that precede it in the enumeration. Note that after
-		/// calling terms(), <see cref="TermEnum.Next()" /> must be called
-		/// on the resulting enumeration before calling other methods such as
-		/// <see cref="TermEnum.Term" />.
-		/// </summary>
-		/// <exception cref="System.IO.IOException">
+        public virtual void  SetNorm(int doc, System.String field, float value)
+        {
+            EnsureOpen();
+            SetNorm(doc, field, Similarity.EncodeNorm(value));
+        }
+        
+        /// <summary>Returns an enumeration of all the terms in the index. The
+        /// enumeration is ordered by Term.compareTo(). Each term is greater
+        /// than all that precede it in the enumeration. Note that after
+        /// calling terms(), <see cref="TermEnum.Next()" /> must be called
+        /// on the resulting enumeration before calling other methods such as
+        /// <see cref="TermEnum.Term" />.
+        /// </summary>
+        /// <exception cref="System.IO.IOException">
         /// If there is a low-level IO error 
-		/// </exception>
-		public abstract TermEnum Terms();
-		
-		/// <summary>Returns an enumeration of all terms starting at a given term. If
-		/// the given term does not exist, the enumeration is positioned at the
-		/// first term greater than the supplied term. The enumeration is
-		/// ordered by Term.compareTo(). Each term is greater than all that
-		/// precede it in the enumeration.
+        /// </exception>
+        public abstract TermEnum Terms();
+        
+        /// <summary>Returns an enumeration of all terms starting at a given term. If
+        /// the given term does not exist, the enumeration is positioned at the
+        /// first term greater than the supplied term. The enumeration is
+        /// ordered by Term.compareTo(). Each term is greater than all that
+        /// precede it in the enumeration.
         /// </summary>
         /// <exception cref="System.IO.IOException">
         /// If there is a low-level IO error
         /// </exception>
-		public abstract TermEnum Terms(Term t);
+        public abstract TermEnum Terms(Term t);
 
         /// <summary>Returns the number of documents containing the term <c>t</c>.</summary>
         /// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
-		public abstract int DocFreq(Term t);
-		
-		/// <summary>Returns an enumeration of all the documents which contain
-		/// <c>term</c>. For each document, the document number, the frequency of
-		/// the term in that document is also provided, for use in
-		/// search scoring.  If term is null, then all non-deleted
-		/// docs are returned with freq=1.
-		/// Thus, this method implements the mapping:
-		/// <p/><list>
-		/// Term &#160;&#160; =&gt; &#160;&#160; &lt;docNum, freq&gt;<sup>*</sup>
-		/// </list>
-		/// <p/>The enumeration is ordered by document number.  Each document number
-		/// is greater than all that precede it in the enumeration.
+        public abstract int DocFreq(Term t);
+        
+        /// <summary>Returns an enumeration of all the documents which contain
+        /// <c>term</c>. For each document, the document number, the frequency of
+        /// the term in that document is also provided, for use in
+        /// search scoring.  If term is null, then all non-deleted
+        /// docs are returned with freq=1.
+        /// Thus, this method implements the mapping:
+        /// <p/><list>
+        /// Term &#160;&#160; =&gt; &#160;&#160; &lt;docNum, freq&gt;<sup>*</sup>
+        /// </list>
+        /// <p/>The enumeration is ordered by document number.  Each document number
+        /// is greater than all that precede it in the enumeration.
         /// </summary>
         /// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
-		public virtual TermDocs TermDocs(Term term)
-		{
-			EnsureOpen();
-			TermDocs termDocs = TermDocs();
-			termDocs.Seek(term);
-			return termDocs;
-		}
+        public virtual TermDocs TermDocs(Term term)
+        {
+            EnsureOpen();
+            TermDocs termDocs = TermDocs();
+            termDocs.Seek(term);
+            return termDocs;
+        }
 
         /// <summary>Returns an unpositioned <see cref="Lucene.Net.Index.TermDocs" /> enumerator.</summary>
         /// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
-		public abstract TermDocs TermDocs();
-		
-		/// <summary>Returns an enumeration of all the documents which contain
-		/// <c>term</c>.  For each document, in addition to the document number
-		/// and frequency of the term in that document, a list of all of the ordinal
-		/// positions of the term in the document is available.  Thus, this method
-		/// implements the mapping:
-		/// 
-		/// <p/><list>
-		/// Term &#160;&#160; =&gt; &#160;&#160; &lt;docNum, freq,
-		/// &lt;pos<sub>1</sub>, pos<sub>2</sub>, ...
-		/// pos<sub>freq-1</sub>&gt;
-		/// &gt;<sup>*</sup>
-		/// </list>
-		/// <p/> This positional information facilitates phrase and proximity searching.
-		/// <p/>The enumeration is ordered by document number.  Each document number is
-		/// greater than all that precede it in the enumeration.
+        public abstract TermDocs TermDocs();
+        
+        /// <summary>Returns an enumeration of all the documents which contain
+        /// <c>term</c>.  For each document, in addition to the document number
+        /// and frequency of the term in that document, a list of all of the ordinal
+        /// positions of the term in the document is available.  Thus, this method
+        /// implements the mapping:
+        /// 
+        /// <p/><list>
+        /// Term &#160;&#160; =&gt; &#160;&#160; &lt;docNum, freq,
+        /// &lt;pos<sub>1</sub>, pos<sub>2</sub>, ...
+        /// pos<sub>freq-1</sub>&gt;
+        /// &gt;<sup>*</sup>
+        /// </list>
+        /// <p/> This positional information facilitates phrase and proximity searching.
+        /// <p/>The enumeration is ordered by document number.  Each document number is
+        /// greater than all that precede it in the enumeration.
         /// </summary>
         /// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
-		public virtual TermPositions TermPositions(Term term)
-		{
-			EnsureOpen();
-			TermPositions termPositions = TermPositions();
-			termPositions.Seek(term);
-			return termPositions;
-		}
+        public virtual TermPositions TermPositions(Term term)
+        {
+            EnsureOpen();
+            TermPositions termPositions = TermPositions();
+            termPositions.Seek(term);
+            return termPositions;
+        }
 
         /// <summary>Returns an unpositioned <see cref="Lucene.Net.Index.TermPositions" /> enumerator.</summary>
         /// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
-		public abstract TermPositions TermPositions();
-		
-		
-		
-		/// <summary>
-		/// Deletes the document numbered <c>docNum</c>.  Once a document is
-		/// deleted it will not appear in TermDocs or TermPostitions enumerations.
-		/// Attempts to read its field with the <see cref="Document(int)" />
-		/// method will result in an error.  The presence of this document may still be
-		/// reflected in the <see cref="DocFreq" /> statistic, though
-		/// this will be corrected eventually as the index is further modified.
-		/// </summary>
-		/// <exception cref="StaleReaderException">
+        public abstract TermPositions TermPositions();
+        
+        
+        
+        /// <summary>
+        /// Deletes the document numbered <c>docNum</c>.  Once a document is
+        /// deleted it will not appear in TermDocs or TermPostitions enumerations.
+        /// Attempts to read its field with the <see cref="Document(int)" />
+        /// method will result in an error.  The presence of this document may still be
+        /// reflected in the <see cref="DocFreq" /> statistic, though
+        /// this will be corrected eventually as the index is further modified.
+        /// </summary>
+        /// <exception cref="StaleReaderException">
         /// If the index has changed since this reader was opened
-		/// </exception>
-		/// <exception cref="CorruptIndexException">If the index is corrupt</exception>
-		/// <exception cref="LockObtainFailedException">
+        /// </exception>
+        /// <exception cref="CorruptIndexException">If the index is corrupt</exception>
+        /// <exception cref="LockObtainFailedException">
         /// If another writer has this index open (<c>write.lock</c> could not be obtained)
         /// </exception>
         /// <exception cref="System.IO.IOException">If there is a low-level IO error</exception>
-		public virtual void  DeleteDocument(int docNum)
-		{
-			lock (this)
-		

<TRUNCATED>

Mime
View raw message