lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From d...@apache.org
Subject [Lucene.Net] svn commit: r1130719 [4/5] - in /incubator/lucene.net/trunk: build/vs2010/contrib/ build/vs2010/test/ doc/contrib/Analyzers/ doc/contrib/FastVectorHighlighter/ doc/core/ src/core/
Date Thu, 02 Jun 2011 18:42:41 GMT
Modified: incubator/lucene.net/trunk/doc/core/Lucene.Net.xml
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/doc/core/Lucene.Net.xml?rev=1130719&r1=1130718&r2=1130719&view=diff
==============================================================================
--- incubator/lucene.net/trunk/doc/core/Lucene.Net.xml (original)
+++ incubator/lucene.net/trunk/doc/core/Lucene.Net.xml Thu Jun  2 18:42:41 2011
@@ -4,69 +4,44 @@
         <name>Lucene.Net</name>
     </assembly>
     <members>
-        <member name="T:Lucene.Net.Util.UnicodeUtil">
-            <summary> Class to encode java's UTF16 char[] into UTF8 byte[]
-            without always allocating a new byte[] as
-            String.getBytes("UTF-8") does.
-            
-            <p/><b>WARNING</b>: This API is a new and experimental and
-            may suddenly change. <p/>
-            </summary>
-        </member>
-        <member name="M:Lucene.Net.Util.UnicodeUtil.UTF16toUTF8(System.Char[],System.Int32,Lucene.Net.Util.UnicodeUtil.UTF8Result)">
-            <summary>Encode characters from a char[] source, starting at
-            offset and stopping when the character 0xffff is seen.
-            Returns the number of bytes written to bytesOut. 
-            </summary>
-        </member>
-        <member name="M:Lucene.Net.Util.UnicodeUtil.UTF16toUTF8(System.Char[],System.Int32,System.Int32,Lucene.Net.Util.UnicodeUtil.UTF8Result)">
-            <summary>Encode characters from a char[] source, starting at
-            offset for length chars.  Returns the number of bytes
-            written to bytesOut. 
-            </summary>
-        </member>
-        <member name="M:Lucene.Net.Util.UnicodeUtil.UTF16toUTF8(System.String,System.Int32,System.Int32,Lucene.Net.Util.UnicodeUtil.UTF8Result)">
-            <summary>Encode characters from this String, starting at offset
-            for length characters.  Returns the number of bytes
-            written to bytesOut. 
-            </summary>
+        <member name="T:Lucene.Net.Util.ToStringUtils">
+            <summary> Helper methods to ease implementing {@link Object#toString()}.</summary>
         </member>
-        <member name="M:Lucene.Net.Util.UnicodeUtil.UTF8toUTF16(System.Byte[],System.Int32,System.Int32,Lucene.Net.Util.UnicodeUtil.UTF16Result)">
-            <summary>Convert UTF8 bytes into UTF16 characters.  If offset
-            is non-zero, conversion starts at that starting point
-            in utf8, re-using the results from the previous call
-            up until offset. 
-            </summary>
+        <member name="M:Lucene.Net.Util.ToStringUtils.Boost(System.Single)">
+            <summary>for printing boost only if not 1.0 </summary>
         </member>
-        <member name="T:Lucene.Net.Util.CloseableThreadLocal">
-            <summary>Java's builtin ThreadLocal has a serious flaw:
-            it can take an arbitrarily long amount of time to
-            dereference the things you had stored in it, even once the
-            ThreadLocal instance itself is no longer referenced.
-            This is because there is single, master map stored for
-            each thread, which all ThreadLocals share, and that
-            master map only periodically purges "stale" entries.
+        <member name="T:Lucene.Net.Store.SimpleFSLockFactory">
+            <summary> <p/>Implements {@link LockFactory} using {@link
+            File#createNewFile()}.<p/>
             
-            While not technically a memory leak, because eventually
-            the memory will be reclaimed, it can take a long time
-            and you can easily hit OutOfMemoryError because from the
-            GC's standpoint the stale entries are not reclaimaible.
+            <p/><b>NOTE:</b> the <a target="_top" href="http://java.sun.com/j2se/1.4.2/docs/api/java/io/File.html#createNewFile()">javadocs
+            for <code>File.createNewFile</code></a> contain a vague
+            yet spooky warning about not using the API for file
+            locking.  This warning was added due to <a target="_top" href="http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4676183">this
+            bug</a>, and in fact the only known problem with using
+            this API for locking is that the Lucene write lock may
+            not be released when the JVM exits abnormally.<p/>
+            <p/>When this happens, a {@link LockObtainFailedException}
+            is hit when trying to create a writer, in which case you
+            need to explicitly clear the lock file first.  You can
+            either manually remove the file, or use the {@link
+            org.apache.lucene.index.IndexReader#unlock(Directory)}
+            API.  But, first be certain that no writer is in fact
+            writing to the index otherwise you can easily corrupt
+            your index.<p/>
+            
+            <p/>If you suspect that this or any other LockFactory is
+            not working properly in your environment, you can easily
+            test it by using {@link VerifyingLockFactory}, {@link
+            LockVerifyServer} and {@link LockStressTest}.<p/>
             
-            This class works around that, by only enrolling
-            WeakReference values into the ThreadLocal, and
-            separately holding a hard reference to each stored
-            value.  When you call {@link #close}, these hard
-            references are cleared and then GC is freely able to
-            reclaim space by objects stored in it. 
-            </summary>
-        </member>
-        <member name="T:Lucene.Net.Store.LockReleaseFailedException">
-            <summary> This exception is thrown when the <code>write.lock</code>
-            could not be released.
             </summary>
-            <seealso cref="!:Lock.release()">
+            <seealso cref="T:Lucene.Net.Store.LockFactory">
             </seealso>
         </member>
+        <member name="T:Lucene.Net.Store.FSLockFactory">
+            <summary> Base class for file system based locking implementation.</summary>
+        </member>
         <member name="T:Lucene.Net.Store.LockFactory">
             <summary> <p/>Base class for Locking implementation.  {@link Directory} uses
             instances of this class to implement locking.<p/>
@@ -111,321 +86,485 @@
             <param name="lockName">name of the lock to be cleared.
             </param>
         </member>
-        <member name="T:Lucene.Net.Store.IndexOutput">
-            <summary>Abstract base class for output to a file in a Directory.  A random-access
-            output stream.  Used for all Lucene index output operations.
+        <member name="F:Lucene.Net.Store.FSLockFactory.lockDir">
+            <summary> Directory for the lock files.</summary>
+        </member>
+        <member name="M:Lucene.Net.Store.FSLockFactory.SetLockDir(System.IO.DirectoryInfo)">
+            <summary> Set the lock directory. This method can be only called
+            once to initialize the lock directory. It is used by {@link FSDirectory}
+            to set the lock directory to itsself.
+            Subclasses can also use this method to set the directory
+            in the constructor.
             </summary>
-            <seealso cref="T:Lucene.Net.Store.Directory">
-            </seealso>
-            <seealso cref="T:Lucene.Net.Store.IndexInput">
-            </seealso>
         </member>
-        <member name="M:Lucene.Net.Store.IndexOutput.WriteByte(System.Byte)">
-            <summary>Writes a single byte.</summary>
-            <seealso cref="M:Lucene.Net.Store.IndexInput.ReadByte">
-            </seealso>
+        <member name="M:Lucene.Net.Store.FSLockFactory.GetLockDir">
+            <summary> Retrieve the lock directory.</summary>
         </member>
-        <member name="M:Lucene.Net.Store.IndexOutput.WriteBytes(System.Byte[],System.Int32)">
-            <summary>Writes an array of bytes.</summary>
-            <param name="b">the bytes to write
-            </param>
-            <param name="length">the number of bytes to write
-            </param>
-            <seealso cref="M:Lucene.Net.Store.IndexInput.ReadBytes(System.Byte[],System.Int32,System.Int32)">
-            </seealso>
+        <member name="M:Lucene.Net.Store.SimpleFSLockFactory.#ctor">
+            <summary> Create a SimpleFSLockFactory instance, with null (unset)
+            lock directory. When you pass this factory to a {@link FSDirectory}
+            subclass, the lock directory is automatically set to the
+            directory itsself. Be sure to create one instance for each directory
+            your create!
+            </summary>
         </member>
-        <member name="M:Lucene.Net.Store.IndexOutput.WriteBytes(System.Byte[],System.Int32,System.Int32)">
-            <summary>Writes an array of bytes.</summary>
-            <param name="b">the bytes to write
-            </param>
-            <param name="offset">the offset in the byte array
+        <member name="M:Lucene.Net.Store.SimpleFSLockFactory.#ctor(System.IO.FileInfo)">
+            <summary> Instantiate using the provided directory (as a File instance).</summary>
+            <param name="lockDir">where lock files should be created.
             </param>
-            <param name="length">the number of bytes to write
+        </member>
+        <member name="M:Lucene.Net.Store.SimpleFSLockFactory.#ctor(System.IO.DirectoryInfo)">
+            <summary> Instantiate using the provided directory (as a File instance).</summary>
+            <param name="lockDir">where lock files should be created.
             </param>
-            <seealso cref="M:Lucene.Net.Store.IndexInput.ReadBytes(System.Byte[],System.Int32,System.Int32)">
-            </seealso>
         </member>
-        <member name="M:Lucene.Net.Store.IndexOutput.WriteInt(System.Int32)">
-            <summary>Writes an int as four bytes.</summary>
-            <seealso cref="M:Lucene.Net.Store.IndexInput.ReadInt">
-            </seealso>
+        <member name="M:Lucene.Net.Store.SimpleFSLockFactory.#ctor(System.String)">
+            <summary> Instantiate using the provided directory name (String).</summary>
+            <param name="lockDirName">where lock files should be created.
+            </param>
         </member>
-        <member name="M:Lucene.Net.Store.IndexOutput.WriteVInt(System.Int32)">
-            <summary>Writes an int in a variable-length format.  Writes between one and
-            five bytes.  Smaller values take fewer bytes.  Negative numbers are not
-            supported.
+        <member name="T:Lucene.Net.Store.Lock">
+            <summary>An interprocess mutex lock.
+            <p/>Typical use might look like:<pre>
+            new Lock.With(directory.makeLock("my.lock")) {
+            public Object doBody() {
+            <i>... code to execute while locked ...</i>
+            }
+            }.run();
+            </pre>
+            
+            
             </summary>
-            <seealso cref="M:Lucene.Net.Store.IndexInput.ReadVInt">
+            <version>  $Id: Lock.java 769409 2009-04-28 14:05:43Z mikemccand $
+            </version>
+            <seealso cref="M:Lucene.Net.Store.Directory.MakeLock(System.String)">
             </seealso>
         </member>
-        <member name="M:Lucene.Net.Store.IndexOutput.WriteLong(System.Int64)">
-            <summary>Writes a long as eight bytes.</summary>
-            <seealso cref="M:Lucene.Net.Store.IndexInput.ReadLong">
-            </seealso>
+        <member name="F:Lucene.Net.Store.Lock.LOCK_OBTAIN_WAIT_FOREVER">
+            <summary>Pass this value to {@link #Obtain(long)} to try
+            forever to obtain the lock. 
+            </summary>
         </member>
-        <member name="M:Lucene.Net.Store.IndexOutput.WriteVLong(System.Int64)">
-            <summary>Writes an long in a variable-length format.  Writes between one and five
-            bytes.  Smaller values take fewer bytes.  Negative numbers are not
-            supported.
+        <member name="F:Lucene.Net.Store.Lock.LOCK_POLL_INTERVAL">
+            <summary>How long {@link #Obtain(long)} waits, in milliseconds,
+            in between attempts to acquire the lock. 
             </summary>
-            <seealso cref="M:Lucene.Net.Store.IndexInput.ReadVLong">
-            </seealso>
         </member>
-        <member name="M:Lucene.Net.Store.IndexOutput.WriteString(System.String)">
-            <summary>Writes a string.</summary>
-            <seealso cref="M:Lucene.Net.Store.IndexInput.ReadString">
-            </seealso>
+        <member name="M:Lucene.Net.Store.Lock.Obtain">
+            <summary>Attempts to obtain exclusive access and immediately return
+            upon success or failure.
+            </summary>
+            <returns> true iff exclusive access is obtained
+            </returns>
         </member>
-        <member name="M:Lucene.Net.Store.IndexOutput.WriteChars(System.String,System.Int32,System.Int32)">
-            <summary>Writes a sub sequence of characters from s as the old
-            format (modified UTF-8 encoded bytes).
+        <member name="F:Lucene.Net.Store.Lock.failureReason">
+            <summary> If a lock obtain called, this failureReason may be set
+            with the "root cause" Exception as to why the lock was
+            not obtained.
             </summary>
-            <param name="s">the source of the characters
-            </param>
-            <param name="start">the first character in the sequence
-            </param>
-            <param name="length">the number of characters in the sequence
-            </param>
-            <deprecated> -- please pre-convert to utf8 bytes
-            instead or use {@link #writeString}
-            </deprecated>
         </member>
-        <member name="M:Lucene.Net.Store.IndexOutput.WriteChars(System.Char[],System.Int32,System.Int32)">
-            <summary>Writes a sub sequence of characters from char[] as
-            the old format (modified UTF-8 encoded bytes).
+        <member name="M:Lucene.Net.Store.Lock.Obtain(System.Int64)">
+            <summary>Attempts to obtain an exclusive lock within amount of
+            time given. Polls once per {@link #LOCK_POLL_INTERVAL}
+            (currently 1000) milliseconds until lockWaitTimeout is
+            passed.
             </summary>
-            <param name="s">the source of the characters
-            </param>
-            <param name="start">the first character in the sequence
-            </param>
-            <param name="length">the number of characters in the sequence
+            <param name="lockWaitTimeout">length of time to wait in
+            milliseconds or {@link
+            #LOCK_OBTAIN_WAIT_FOREVER} to retry forever
             </param>
-            <deprecated> -- please pre-convert to utf8 bytes instead or use {@link #writeString}
-            </deprecated>
+            <returns> true if lock was obtained
+            </returns>
+            <throws>  LockObtainFailedException if lock wait times out </throws>
+            <throws>  IllegalArgumentException if lockWaitTimeout is </throws>
+            <summary>         out of bounds
+            </summary>
+            <throws>  IOException if obtain() throws IOException </throws>
         </member>
-        <member name="M:Lucene.Net.Store.IndexOutput.CopyBytes(Lucene.Net.Store.IndexInput,System.Int64)">
-            <summary>Copy numBytes bytes from input to ourself. </summary>
+        <member name="M:Lucene.Net.Store.Lock.Release">
+            <summary>Releases exclusive access. </summary>
         </member>
-        <member name="M:Lucene.Net.Store.IndexOutput.Flush">
-            <summary>Forces any buffered output to be written. </summary>
+        <member name="M:Lucene.Net.Store.Lock.IsLocked">
+            <summary>Returns true if the resource is currently locked.  Note that one must
+            still call {@link #Obtain()} before using the resource. 
+            </summary>
         </member>
-        <member name="M:Lucene.Net.Store.IndexOutput.Close">
-            <summary>Closes this stream to further operations. </summary>
+        <member name="T:Lucene.Net.Store.Lock.With">
+            <summary>Utility class for executing code with exclusive access. </summary>
         </member>
-        <member name="M:Lucene.Net.Store.IndexOutput.GetFilePointer">
-            <summary>Returns the current position in this file, where the next write will
-            occur.
-            </summary>
-            <seealso cref="M:Lucene.Net.Store.IndexOutput.Seek(System.Int64)">
-            </seealso>
+        <member name="M:Lucene.Net.Store.Lock.With.#ctor(Lucene.Net.Store.Lock,System.Int64)">
+            <summary>Constructs an executor that will grab the named lock. </summary>
         </member>
-        <member name="M:Lucene.Net.Store.IndexOutput.Seek(System.Int64)">
-            <summary>Sets current position in this file, where the next write will occur.</summary>
-            <seealso cref="M:Lucene.Net.Store.IndexOutput.GetFilePointer">
-            </seealso>
+        <member name="M:Lucene.Net.Store.Lock.With.DoBody">
+            <summary>Code to execute with exclusive access. </summary>
         </member>
-        <member name="M:Lucene.Net.Store.IndexOutput.Length">
-            <summary>The number of bytes in the file. </summary>
+        <member name="M:Lucene.Net.Store.Lock.With.run">
+            <summary>Calls {@link #doBody} while <i>lock</i> is obtained.  Blocks if lock
+            cannot be obtained immediately.  Retries to obtain lock once per second
+            until it is obtained, or until it has tried ten times. Lock is released when
+            {@link #doBody} exits.
+            </summary>
+            <throws>  LockObtainFailedException if lock could not </throws>
+            <summary> be obtained
+            </summary>
+            <throws>  IOException if {@link Lock#obtain} throws IOException </throws>
         </member>
-        <member name="M:Lucene.Net.Store.IndexOutput.SetLength(System.Int64)">
-            <summary>Set the file length. By default, this method does
-            nothing (it's optional for a Directory to implement
-            it).  But, certain Directory implementations (for
+        <member name="M:Lucene.Net.Store.RAMFile.NewBuffer(System.Int32)">
+            <summary> Expert: allocate a new buffer. 
+            Subclasses can allocate differently. 
             </summary>
-            <seealso cref="T:Lucene.Net.Store.FSDirectory"> can use this to inform the
-            underlying IO system to pre-allocate the file to the
-            specified size.  If the length is longer than the
-            current file length, the bytes added to the file are
-            undefined.  Otherwise the file is truncated.
-            </seealso>
-            <param name="length">file length
+            <param name="size">size of allocated buffer.
             </param>
+            <returns> allocated buffer.
+            </returns>
         </member>
-        <member name="T:Lucene.Net.Store.ChecksumIndexOutput">
-            <summary>Writes bytes through to a primary IndexOutput, computing
-            checksum.  Note that you cannot use seek().
+        <member name="T:Lucene.Net.Search.TopFieldDocCollector">
+            <summary>A {@link HitCollector} implementation that collects the top-sorting
+            documents, returning them as a {@link TopFieldDocs}.  This is used by {@link
+            IndexSearcher} to implement {@link TopFieldDocs}-based search.
+            
+            <p/>This may be extended, overriding the collect method to, e.g.,
+            conditionally invoke <code>super()</code> in order to filter which
+            documents are collected.
+            
             </summary>
+            <deprecated> Please use {@link TopFieldCollector} instead.
+            </deprecated>
         </member>
-        <member name="M:Lucene.Net.Store.ChecksumIndexOutput.PrepareCommit">
-            <summary> Starts but does not complete the commit of this file (=
-            writing of the final checksum at the end).  After this
-            is called must call {@link #finishCommit} and the
-            {@link #close} to complete the commit.
+        <member name="T:Lucene.Net.Search.TopDocCollector">
+            <summary>A {@link HitCollector} implementation that collects the top-scoring
+            documents, returning them as a {@link TopDocs}.  This is used by {@link
+            IndexSearcher} to implement {@link TopDocs}-based search.
+            
+            <p/>This may be extended, overriding the collect method to, e.g.,
+            conditionally invoke <code>super()</code> in order to filter which
+            documents are collected.
+            
             </summary>
+            <deprecated> Please use {@link TopScoreDocCollector}
+            instead, which has better performance.
+            
+            </deprecated>
         </member>
-        <member name="M:Lucene.Net.Store.ChecksumIndexOutput.FinishCommit">
-            <summary>See {@link #prepareCommit} </summary>
-        </member>
-        <member name="T:Lucene.Net.Store.ChecksumIndexInput">
-            <summary>Writes bytes through to a primary IndexOutput, computing
-            checksum as it goes. Note that you cannot use seek(). 
+        <member name="T:Lucene.Net.Search.HitCollector">
+            <summary> Lower-level search API. <br/>
+            HitCollectors are primarily meant to be used to implement queries, sorting
+            and filtering. See {@link Collector} for a lower level and higher performance
+            (on a multi-segment index) API.
+            
             </summary>
+            <seealso cref="M:Lucene.Net.Search.Searcher.Search(Lucene.Net.Search.Query,Lucene.Net.Search.HitCollector)">
+            </seealso>
+            <version>  $Id: HitCollector.java 764551 2009-04-13 18:33:56Z mikemccand $
+            </version>
+            <deprecated> Please use {@link Collector} instead.
+            </deprecated>
         </member>
-        <member name="T:Lucene.Net.Store.IndexInput">
-            <summary>Abstract base class for input from a file in a {@link Directory}.  A
-            random-access input stream.  Used for all Lucene index input operations.
+        <member name="M:Lucene.Net.Search.HitCollector.Collect(System.Int32,System.Single)">
+            <summary>Called once for every document matching a query, with the document
+            number and its raw score.
+            
+            <p/>If, for example, an application wished to collect all of the hits for a
+            query in a BitSet, then it might:<pre>
+            Searcher searcher = new IndexSearcher(indexReader);
+            final BitSet bits = new BitSet(indexReader.maxDoc());
+            searcher.search(query, new HitCollector() {
+            public void collect(int doc, float score) {
+            bits.set(doc);
+            }
+            });
+            </pre>
+            
+            <p/>Note: This is called in an inner search loop.  For good search
+            performance, implementations of this method should not call
+            {@link Searcher#Doc(int)} or
+            {@link Lucene.Net.Index.IndexReader#Document(int)} on every
+            document number encountered.  Doing so can slow searches by an order
+            of magnitude or more.
+            <p/>Note: The <code>score</code> passed to this method is a raw score.
+            In other words, the score will not necessarily be a float whose value is
+            between 0 and 1.
             </summary>
-            <seealso cref="T:Lucene.Net.Store.Directory">
-            </seealso>
         </member>
-        <member name="M:Lucene.Net.Store.IndexInput.ReadByte">
-            <summary>Reads and returns a single byte.</summary>
-            <seealso cref="M:Lucene.Net.Store.IndexOutput.WriteByte(System.Byte)">
-            </seealso>
+        <member name="F:Lucene.Net.Search.TopDocCollector.totalHits">
+            <summary>The total number of hits the collector encountered. </summary>
         </member>
-        <member name="M:Lucene.Net.Store.IndexInput.ReadBytes(System.Byte[],System.Int32,System.Int32)">
-            <summary>Reads a specified number of bytes into an array at the specified offset.</summary>
-            <param name="b">the array to read bytes into
-            </param>
-            <param name="offset">the offset in the array to start storing bytes
-            </param>
-            <param name="len">the number of bytes to read
+        <member name="F:Lucene.Net.Search.TopDocCollector.hq">
+            <summary>The priority queue which holds the top-scoring documents. </summary>
+        </member>
+        <member name="M:Lucene.Net.Search.TopDocCollector.#ctor(System.Int32)">
+            <summary>Construct to collect a given number of hits.</summary>
+            <param name="numHits">the maximum number of hits to collect
             </param>
-            <seealso cref="M:Lucene.Net.Store.IndexOutput.WriteBytes(System.Byte[],System.Int32)">
-            </seealso>
         </member>
-        <member name="M:Lucene.Net.Store.IndexInput.ReadBytes(System.Byte[],System.Int32,System.Int32,System.Boolean)">
-            <summary>Reads a specified number of bytes into an array at the
-            specified offset with control over whether the read
-            should be buffered (callers who have their own buffer
-            should pass in "false" for useBuffer).  Currently only
-            {@link BufferedIndexInput} respects this parameter.
-            </summary>
-            <param name="b">the array to read bytes into
+        <member name="M:Lucene.Net.Search.TopDocCollector.#ctor(System.Int32,Lucene.Net.Util.PriorityQueue)">
+            <deprecated> use TopDocCollector(hq) instead. numHits is not used by this
+            constructor. It will be removed in a future release.
+            </deprecated>
+        </member>
+        <member name="M:Lucene.Net.Search.TopDocCollector.#ctor(Lucene.Net.Util.PriorityQueue)">
+            <summary>Constructor to collect the top-scoring documents by using the given PQ.</summary>
+            <param name="hq">the PQ to use by this instance.
             </param>
-            <param name="offset">the offset in the array to start storing bytes
+        </member>
+        <member name="M:Lucene.Net.Search.TopDocCollector.GetTotalHits">
+            <summary>The total number of documents that matched this query. </summary>
+        </member>
+        <member name="M:Lucene.Net.Search.TopDocCollector.TopDocs">
+            <summary>The top-scoring hits. </summary>
+        </member>
+        <member name="M:Lucene.Net.Search.TopFieldDocCollector.#ctor(Lucene.Net.Index.IndexReader,Lucene.Net.Search.Sort,System.Int32)">
+            <summary>Construct to collect a given number of hits.</summary>
+            <param name="reader">the index to be searched
             </param>
-            <param name="len">the number of bytes to read
+            <param name="sort">the sort criteria
             </param>
-            <param name="useBuffer">set to false if the caller will handle
-            buffering.
+            <param name="numHits">the maximum number of hits to collect
             </param>
-            <seealso cref="M:Lucene.Net.Store.IndexOutput.WriteBytes(System.Byte[],System.Int32)">
-            </seealso>
         </member>
-        <member name="M:Lucene.Net.Store.IndexInput.ReadInt">
-            <summary>Reads four bytes and returns an int.</summary>
-            <seealso cref="M:Lucene.Net.Store.IndexOutput.WriteInt(System.Int32)">
-            </seealso>
+        <member name="T:Lucene.Net.Search.Spans.SpanTermQuery">
+            <summary>Matches spans containing a term. </summary>
         </member>
-        <member name="M:Lucene.Net.Store.IndexInput.ReadVInt">
-            <summary>Reads an int stored in variable-length format.  Reads between one and
-            five bytes.  Smaller values take fewer bytes.  Negative numbers are not
-            supported.
+        <member name="T:Lucene.Net.Search.Spans.SpanQuery">
+            <summary>Base class for span-based queries. </summary>
+        </member>
+        <member name="T:Lucene.Net.Search.Query">
+            <summary>The abstract base class for queries.
+            <p/>Instantiable subclasses are:
+            <ul>
+            <li> {@link TermQuery} </li>
+            <li> {@link MultiTermQuery} </li>
+            <li> {@link BooleanQuery} </li>
+            <li> {@link WildcardQuery} </li>
+            <li> {@link PhraseQuery} </li>
+            <li> {@link PrefixQuery} </li>
+            <li> {@link MultiPhraseQuery} </li>
+            <li> {@link FuzzyQuery} </li>
+            <li> {@link TermRangeQuery} </li>
+            <li> {@link NumericRangeQuery} </li>
+            <li> {@link Lucene.Net.Search.Spans.SpanQuery} </li>
+            </ul>
+            <p/>A parser for queries is contained in:
+            <ul>
+            <li>{@link Lucene.Net.QueryParsers.QueryParser QueryParser} </li>
+            </ul>
             </summary>
-            <seealso cref="M:Lucene.Net.Store.IndexOutput.WriteVInt(System.Int32)">
-            </seealso>
         </member>
-        <member name="M:Lucene.Net.Store.IndexInput.ReadLong">
-            <summary>Reads eight bytes and returns a long.</summary>
-            <seealso cref="M:Lucene.Net.Store.IndexOutput.WriteLong(System.Int64)">
-            </seealso>
+        <member name="M:Lucene.Net.Search.Query.SetBoost(System.Single)">
+            <summary>Sets the boost for this query clause to <code>b</code>.  Documents
+            matching this clause will (in addition to the normal weightings) have
+            their score multiplied by <code>b</code>.
+            </summary>
         </member>
-        <member name="M:Lucene.Net.Store.IndexInput.ReadVLong">
-            <summary>Reads a long stored in variable-length format.  Reads between one and
-            nine bytes.  Smaller values take fewer bytes.  Negative numbers are not
-            supported. 
+        <member name="M:Lucene.Net.Search.Query.GetBoost">
+            <summary>Gets the boost for this clause.  Documents matching
+            this clause will (in addition to the normal weightings) have their score
+            multiplied by <code>b</code>.   The boost is 1.0 by default.
             </summary>
         </member>
-        <member name="M:Lucene.Net.Store.IndexInput.SetModifiedUTF8StringsMode">
-            <summary>Call this if readString should read characters stored
-            in the old modified UTF8 format (length in java chars
-            and java's modified UTF8 encoding).  This is used for
-            indices written pre-2.4 See LUCENE-510 for details. 
+        <member name="M:Lucene.Net.Search.Query.ToString(System.String)">
+            <summary>Prints a query to a string, with <code>field</code> assumed to be the 
+            default field and omitted.
+            <p/>The representation used is one that is supposed to be readable
+            by {@link Lucene.Net.QueryParsers.QueryParser QueryParser}. However,
+            there are the following limitations:
+            <ul>
+            <li>If the query was created by the parser, the printed
+            representation may not be exactly what was parsed. For example,
+            characters that need to be escaped will be represented without
+            the required backslash.</li>
+            <li>Some of the more complicated queries (e.g. span queries)
+            don't have a representation that can be parsed by QueryParser.</li>
+            </ul>
             </summary>
         </member>
-        <member name="M:Lucene.Net.Store.IndexInput.ReadString">
-            <summary>Reads a string.</summary>
-            <seealso cref="M:Lucene.Net.Store.IndexOutput.WriteString(System.String)">
-            </seealso>
+        <member name="M:Lucene.Net.Search.Query.ToString">
+            <summary>Prints a query to a string. </summary>
         </member>
-        <member name="M:Lucene.Net.Store.IndexInput.ReadChars(System.Char[],System.Int32,System.Int32)">
-            <summary>Reads Lucene's old "modified UTF-8" encoded
-            characters into an array.
+        <member name="M:Lucene.Net.Search.Query.CreateWeight(Lucene.Net.Search.Searcher)">
+            <summary> Expert: Constructs an appropriate Weight implementation for this query.
+            
+            <p/>
+            Only implemented by primitive queries, which re-write to themselves.
             </summary>
-            <param name="buffer">the array to read characters into
-            </param>
-            <param name="start">the offset in the array to start storing characters
-            </param>
-            <param name="length">the number of characters to read
-            </param>
-            <seealso cref="M:Lucene.Net.Store.IndexOutput.WriteChars(System.String,System.Int32,System.Int32)">
-            </seealso>
-            <deprecated> -- please use readString or readBytes
-            instead, and construct the string
-            from those utf8 bytes
-            </deprecated>
         </member>
-        <member name="M:Lucene.Net.Store.IndexInput.SkipChars(System.Int32)">
-            <summary> Expert
+        <member name="M:Lucene.Net.Search.Query.Weight(Lucene.Net.Search.Searcher)">
+            <summary> Expert: Constructs and initializes a Weight for a top-level query.</summary>
+        </member>
+        <member name="M:Lucene.Net.Search.Query.Rewrite(Lucene.Net.Index.IndexReader)">
+            <summary>Expert: called to re-write queries into primitive queries. For example,
+            a PrefixQuery will be rewritten into a BooleanQuery that consists
+            of TermQuerys.
+            </summary>
+        </member>
+        <member name="M:Lucene.Net.Search.Query.Combine(Lucene.Net.Search.Query[])">
+            <summary>Expert: called when re-writing queries under MultiSearcher.
             
-            Similar to {@link #ReadChars(char[], int, int)} but does not do any conversion operations on the bytes it is reading in.  It still
-            has to invoke {@link #ReadByte()} just as {@link #ReadChars(char[], int, int)} does, but it does not need a buffer to store anything
-            and it does not have to do any of the bitwise operations, since we don't actually care what is in the byte except to determine
-            how many more bytes to read
+            Create a single query suitable for use by all subsearchers (in 1-1
+            correspondence with queries). This is an optimization of the OR of
+            all queries. We handle the common optimization cases of equal
+            queries and overlapping clauses of boolean OR queries (as generated
+            by MultiTermQuery.rewrite()).
+            Be careful overriding this method as queries[0] determines which
+            method will be called and is not necessarily of the same type as
+            the other queries.
             </summary>
-            <param name="length">The number of chars to read
-            </param>
-            <deprecated> this method operates on old "modified utf8" encoded
-            strings
-            </deprecated>
         </member>
-        <member name="M:Lucene.Net.Store.IndexInput.Close">
-            <summary>Closes the stream to futher operations. </summary>
+        <member name="M:Lucene.Net.Search.Query.ExtractTerms(System.Collections.Hashtable)">
+            <summary> Expert: adds all terms occuring in this query to the terms set. Only
+            works if this query is in its {@link #rewrite rewritten} form.
+            
+            </summary>
+            <throws>  UnsupportedOperationException if this query is not yet rewritten </throws>
         </member>
-        <member name="M:Lucene.Net.Store.IndexInput.GetFilePointer">
-            <summary>Returns the current position in this file, where the next read will
-            occur.
+        <member name="M:Lucene.Net.Search.Query.MergeBooleanQueries(Lucene.Net.Search.BooleanQuery[])">
+            <summary>Expert: merges the clauses of a set of BooleanQuery's into a single
+            BooleanQuery.
+            
+            <p/>A utility for use by {@link #Combine(Query[])} implementations.
             </summary>
-            <seealso cref="M:Lucene.Net.Store.IndexInput.Seek(System.Int64)">
+        </member>
+        <member name="M:Lucene.Net.Search.Query.GetSimilarity(Lucene.Net.Search.Searcher)">
+            <summary>Expert: Returns the Similarity implementation to be used for this query.
+            Subclasses may override this method to specify their own Similarity
+            implementation, perhaps one that delegates through that of the Searcher.
+            By default the Searcher's Similarity implementation is returned.
+            </summary>
+        </member>
+        <member name="M:Lucene.Net.Search.Query.Clone">
+            <summary>Returns a clone of this query. </summary>
+        </member>
+        <member name="M:Lucene.Net.Search.Spans.SpanQuery.GetSpans(Lucene.Net.Index.IndexReader)">
+            <summary>Expert: Returns the matches for this query in an index.  Used internally
+            to search for spans. 
+            </summary>
+        </member>
+        <member name="M:Lucene.Net.Search.Spans.SpanQuery.GetField">
+            <summary>Returns the name of the field matched by this query.</summary>
+        </member>
+        <member name="M:Lucene.Net.Search.Spans.SpanQuery.GetTerms">
+            <summary>Returns a collection of all terms matched by this query.</summary>
+            <deprecated> use extractTerms instead
+            </deprecated>
+            <seealso cref="!:Query.ExtractTerms(Set)">
             </seealso>
         </member>
-        <member name="M:Lucene.Net.Store.IndexInput.Seek(System.Int64)">
-            <summary>Sets current position in this file, where the next read will occur.</summary>
-            <seealso cref="M:Lucene.Net.Store.IndexInput.GetFilePointer">
+        <member name="M:Lucene.Net.Search.Spans.SpanTermQuery.#ctor(Lucene.Net.Index.Term)">
+            <summary>Construct a SpanTermQuery matching the named term's spans. </summary>
+        </member>
+        <member name="M:Lucene.Net.Search.Spans.SpanTermQuery.GetTerm">
+            <summary>Return the term whose spans are matched. </summary>
+        </member>
+        <member name="M:Lucene.Net.Search.Spans.SpanTermQuery.GetTerms">
+            <summary>Returns a collection of all terms matched by this query.</summary>
+            <deprecated> use extractTerms instead
+            </deprecated>
+            <seealso cref="!:ExtractTerms(Set)">
             </seealso>
         </member>
-        <member name="M:Lucene.Net.Store.IndexInput.Length">
-            <summary>The number of bytes in the file. </summary>
+        <member name="T:Lucene.Net.Search.Spans.SpanFirstQuery">
+            <summary>Matches spans near the beginning of a field. </summary>
         </member>
-        <member name="M:Lucene.Net.Store.IndexInput.Clone">
-            <summary>Returns a clone of this stream.
+        <member name="M:Lucene.Net.Search.Spans.SpanFirstQuery.#ctor(Lucene.Net.Search.Spans.SpanQuery,System.Int32)">
+            <summary>Construct a SpanFirstQuery matching spans in <code>match</code> whose end
+            position is less than or equal to <code>end</code>. 
+            </summary>
+        </member>
+        <member name="M:Lucene.Net.Search.Spans.SpanFirstQuery.GetMatch">
+            <summary>Return the SpanQuery whose matches are filtered. </summary>
+        </member>
+        <member name="M:Lucene.Net.Search.Spans.SpanFirstQuery.GetEnd">
+            <summary>Return the maximum end position permitted in a match. </summary>
+        </member>
+        <member name="M:Lucene.Net.Search.Spans.SpanFirstQuery.GetTerms">
+            <summary>Returns a collection of all terms matched by this query.</summary>
+            <deprecated> use extractTerms instead
+            </deprecated>
+            <seealso cref="!:ExtractTerms(Set)">
+            </seealso>
+        </member>
+        <member name="T:Lucene.Net.Search.Spans.Spans">
+            <summary>Expert: an enumeration of span matches.  Used to implement span searching.
+            Each span represents a range of term positions within a document.  Matches
+            are enumerated in order, by increasing document number, within that by
+            increasing start position and finally by increasing end position. 
+            </summary>
+        </member>
+        <member name="M:Lucene.Net.Search.Spans.Spans.Next">
+            <summary>Move to the next match, returning true iff any such exists. </summary>
+        </member>
+        <member name="M:Lucene.Net.Search.Spans.Spans.SkipTo(System.Int32)">
+            <summary>Skips to the first match beyond the current, whose document number is
+            greater than or equal to <i>target</i>. <p/>Returns true iff there is such
+            a match.  <p/>Behaves as if written: <pre>
+            boolean skipTo(int target) {
+            do {
+            if (!next())
+            return false;
+            } while (target > doc());
+            return true;
+            }
+            </pre>
+            Most implementations are considerably more efficient than that.
+            </summary>
+        </member>
+        <member name="M:Lucene.Net.Search.Spans.Spans.Doc">
+            <summary>Returns the document number of the current match.  Initially invalid. </summary>
+        </member>
+        <member name="M:Lucene.Net.Search.Spans.Spans.Start">
+            <summary>Returns the start position of the current match.  Initially invalid. </summary>
+        </member>
+        <member name="M:Lucene.Net.Search.Spans.Spans.End">
+            <summary>Returns the end position of the current match.  Initially invalid. </summary>
+        </member>
+        <member name="M:Lucene.Net.Search.Spans.Spans.GetPayload">
+            <summary> Returns the payload data for the current span.
+            This is invalid until {@link #Next()} is called for
+            the first time.
+            This method must not be called more than once after each call
+            of {@link #Next()}. However, most payloads are loaded lazily,
+            so if the payload data for the current position is not needed,
+            this method may not be called at all for performance reasons. An ordered
+            SpanQuery does not lazy load, so if you have payloads in your index and
+            you do not want ordered SpanNearQuerys to collect payloads, you can
+            disable collection with a constructor option.<br/>
             
-            <p/>Clones of a stream access the same data, and are positioned at the same
-            point as the stream they were cloned from.
+            Note that the return type is a collection, thus the ordering should not be relied upon.
+            <br/>
+            <p/><font color="#FF0000">
+            WARNING: The status of the <b>Payloads</b> feature is experimental.
+            The APIs introduced here might change in the future and will not be
+            supported anymore in such a case.</font><p/>
             
-            <p/>Expert: Subclasses must ensure that clones may be positioned at
-            different points in the input from each other and from the stream they
-            were cloned from.
             </summary>
+            <returns> a List of byte arrays containing the data of this payload, otherwise null if isPayloadAvailable is false
+            </returns>
+            <throws>  java.io.IOException </throws>
         </member>
-        <member name="T:Lucene.Net.Search.TermRangeFilter">
-            <summary> A Filter that restricts search results to a range of values in a given
-            field.
+        <member name="M:Lucene.Net.Search.Spans.Spans.IsPayloadAvailable">
+            <summary> Checks if a payload can be loaded at this position.
+            <p/>
+            Payloads can only be loaded once per call to
+            {@link #Next()}.
             
-            <p/>This filter matches the documents looking for terms that fall into the
-            supplied range according to {@link String#compareTo(String)}. It is not intended
-            for numerical ranges, use {@link NumericRangeFilter} instead.
+            </summary>
+            <returns> true if there is a payload available at this position that can be loaded
+            </returns>
+        </member>
+        <member name="T:Lucene.Net.Search.QueryFilter">
+            <summary>Constrains search results to only match those which also match a provided
+            query.  Results are cached, so that searches after the first on the same
+            index using this filter are much faster.
             
-            <p/>If you construct a large number of range filters with different ranges but on the 
-            same field, {@link FieldCacheRangeFilter} may have significantly better performance. 
             </summary>
-            <since> 2.9
-            </since>
+            <version>  $Id: QueryFilter.java 528298 2007-04-13 00:59:28Z hossman $
+            </version>
+            <deprecated> use a CachingWrapperFilter with QueryWrapperFilter
+            </deprecated>
         </member>
-        <member name="T:Lucene.Net.Search.MultiTermQueryWrapperFilter">
-            <summary> A wrapper for {@link MultiTermQuery}, that exposes its
-            functionality as a {@link Filter}.
-            <p/>
-            <code>MultiTermQueryWrapperFilter</code> is not designed to
-            be used by itself. Normally you subclass it to provide a Filter
-            counterpart for a {@link MultiTermQuery} subclass.
-            <p/>
-            For example, {@link TermRangeFilter} and {@link PrefixFilter} extend
-            <code>MultiTermQueryWrapperFilter</code>.
-            This class also provides the functionality behind
-            {@link MultiTermQuery#CONSTANT_SCORE_FILTER_REWRITE};
-            this is why it is not abstract.
+        <member name="T:Lucene.Net.Search.CachingWrapperFilter">
+            <summary> Wraps another filter's result and caches it.  The purpose is to allow
+            filters to simply filter, and then wrap with this class to add caching.
             </summary>
         </member>
         <member name="T:Lucene.Net.Search.Filter">
@@ -462,1306 +601,881 @@
              <seealso cref="T:Lucene.Net.Util.DocIdBitSet">
              </seealso>
         </member>
-        <member name="M:Lucene.Net.Search.MultiTermQueryWrapperFilter.#ctor(Lucene.Net.Search.MultiTermQuery)">
-            <summary> Wrap a {@link MultiTermQuery} as a Filter.</summary>
+        <member name="M:Lucene.Net.Search.CachingWrapperFilter.#ctor(Lucene.Net.Search.Filter)">
+            New deletes are ignored by default, which gives higher
+            cache hit rate on reopened readers.  Most of the time
+            this is safe, because the filter will be AND'd with a
+            Query that fully enforces deletions.  If instead you
+            need this filter to always enforce deletions, pass
+            either {@link DeletesMode#RECACHE} or {@link
+            DeletesMode#DYNAMIC}.
+            @param filter Filter to cache results of
         </member>
-        <member name="M:Lucene.Net.Search.MultiTermQueryWrapperFilter.GetTotalNumberOfTerms">
-            <summary> Expert: Return the number of unique terms visited during execution of the filter.
-            If there are many of them, you may consider using another filter type
-            or optimize your total term count in index.
-            <p/>This method is not thread safe, be sure to only call it when no filter is running!
-            If you re-use the same filter instance for another
-            search, be sure to first reset the term counter
-            with {@link #clearTotalNumberOfTerms}.
-            </summary>
-            <seealso cref="!:clearTotalNumberOfTerms">
-            </seealso>
+        <member name="M:Lucene.Net.Search.CachingWrapperFilter.#ctor(Lucene.Net.Search.Filter,Lucene.Net.Search.CachingWrapperFilter.DeletesMode)">
+             Expert: by default, the cached filter will be shared
+             across reopened segments that only had changes to their
+             deletions.  
+            
+             @param filter Filter to cache results of
+             @param deletesMode See {@link DeletesMode}
         </member>
-        <member name="M:Lucene.Net.Search.MultiTermQueryWrapperFilter.ClearTotalNumberOfTerms">
-            <summary> Expert: Resets the counting of unique terms.
-            Do this before executing the filter.
-            </summary>
-            <seealso cref="!:getTotalNumberOfTerms">
-            </seealso>
-        </member>
-        <member name="M:Lucene.Net.Search.MultiTermQueryWrapperFilter.Bits(Lucene.Net.Index.IndexReader)">
-            <summary> Returns a BitSet with true for documents which should be
-            permitted in search results, and false for those that should
-            not.
-            </summary>
+        <member name="M:Lucene.Net.Search.CachingWrapperFilter.Bits(Lucene.Net.Index.IndexReader)">
             <deprecated> Use {@link #GetDocIdSet(IndexReader)} instead.
             </deprecated>
         </member>
-        <member name="M:Lucene.Net.Search.MultiTermQueryWrapperFilter.GetDocIdSet(Lucene.Net.Index.IndexReader)">
-            <summary> Returns a DocIdSet with documents that should be
-            permitted in search results.
-            </summary>
-        </member>
-        <member name="M:Lucene.Net.Search.TermRangeFilter.#ctor(System.String,System.String,System.String,System.Boolean,System.Boolean)">
-            <param name="fieldName">The field this range applies to
-            </param>
-            <param name="lowerTerm">The lower bound on this range
-            </param>
-            <param name="upperTerm">The upper bound on this range
-            </param>
-            <param name="includeLower">Does this range include the lower bound?
-            </param>
-            <param name="includeUpper">Does this range include the upper bound?
-            </param>
-            <throws>  IllegalArgumentException if both terms are null or if </throws>
-            <summary>  lowerTerm is null and includeLower is true (similar for upperTerm
-            and includeUpper)
+        <member name="M:Lucene.Net.Search.CachingWrapperFilter.DocIdSetToCache(Lucene.Net.Search.DocIdSet,Lucene.Net.Index.IndexReader)">
+            <summary>Provide the DocIdSet to be cached, using the DocIdSet provided
+            by the wrapped Filter.
+            This implementation returns the given DocIdSet.
             </summary>
         </member>
-        <member name="M:Lucene.Net.Search.TermRangeFilter.#ctor(System.String,System.String,System.String,System.Boolean,System.Boolean,System.Globalization.CompareInfo)">
-            <summary> <strong>WARNING:</strong> Using this constructor and supplying a non-null
-            value in the <code>collator</code> parameter will cause every single 
-            index Term in the Field referenced by lowerTerm and/or upperTerm to be
-            examined.  Depending on the number of index Terms in this Field, the 
-            operation could be very slow.
+        <member name="T:Lucene.Net.Search.CachingWrapperFilter.DeletesMode">
+             Expert: Specifies how new deletions against a reopened
+             reader should be handled.
             
-            </summary>
-            <param name="lowerTerm">The lower bound on this range
-            </param>
-            <param name="upperTerm">The upper bound on this range
-            </param>
-            <param name="includeLower">Does this range include the lower bound?
-            </param>
-            <param name="includeUpper">Does this range include the upper bound?
-            </param>
-            <param name="collator">The collator to use when determining range inclusion; set
-            to null to use Unicode code point ordering instead of collation.
-            </param>
-            <throws>  IllegalArgumentException if both terms are null or if </throws>
-            <summary>  lowerTerm is null and includeLower is true (similar for upperTerm
-            and includeUpper)
-            </summary>
+             <p>The default is IGNORE, which means the cache entry
+             will be re-used for a given segment, even when that
+             segment has been reopened due to changes in deletions.
+             This is a big performance gain, especially with
+             near-real-timer readers, since you don't hit a cache
+             miss on every reopened reader for prior segments.</p>
+            
+             <p>However, in some cases this can cause invalid query
+             results, allowing deleted documents to be returned.
+             This only happens if the main query does not rule out
+             deleted documents on its own, such as a toplevel
+             ConstantScoreQuery.  To fix this, use RECACHE to
+             re-create the cached filter (at a higher per-reopen
+             cost, but at faster subsequent search performance), or
+             use DYNAMIC to dynamically intersect deleted docs (fast
+             reopen time but some hit to search performance).</p>
         </member>
-        <member name="M:Lucene.Net.Search.TermRangeFilter.Less(System.String,System.String)">
-            <summary> Constructs a filter for field <code>fieldName</code> matching
-            less than or equal to <code>upperTerm</code>.
-            </summary>
+        <member name="T:Lucene.Net.Util.Parameter">
+            <summary> A serializable Enum class.</summary>
         </member>
-        <member name="M:Lucene.Net.Search.TermRangeFilter.More(System.String,System.String)">
-            <summary> Constructs a filter for field <code>fieldName</code> matching
-            greater than or equal to <code>lowerTerm</code>.
+        <member name="M:Lucene.Net.Util.Parameter.Equals(System.Object)">
+            <summary> Resolves the deserialized instance to the local reference for accurate
+            equals() and == comparisons.
+            
             </summary>
+            <returns> a reference to Parameter as resolved in the local VM
+            </returns>
+            <throws>  ObjectStreamException </throws>
         </member>
-        <member name="M:Lucene.Net.Search.TermRangeFilter.GetField">
-            <summary>Returns the field name for this filter </summary>
-        </member>
-        <member name="M:Lucene.Net.Search.TermRangeFilter.GetLowerTerm">
-            <summary>Returns the lower value of this range filter </summary>
-        </member>
-        <member name="M:Lucene.Net.Search.TermRangeFilter.GetUpperTerm">
-            <summary>Returns the upper value of this range filter </summary>
-        </member>
-        <member name="M:Lucene.Net.Search.TermRangeFilter.IncludesLower">
-            <summary>Returns <code>true</code> if the lower endpoint is inclusive </summary>
-        </member>
-        <member name="M:Lucene.Net.Search.TermRangeFilter.IncludesUpper">
-            <summary>Returns <code>true</code> if the upper endpoint is inclusive </summary>
+        <member name="F:Lucene.Net.Search.CachingWrapperFilter.FilterCache.cache">
+            A transient Filter cache (package private because of test)
         </member>
-        <member name="M:Lucene.Net.Search.TermRangeFilter.GetCollator">
-            <summary>Returns the collator used to determine range inclusion, if any. </summary>
+        <member name="T:Lucene.Net.Search.FilteredDocIdSet">
+            <summary> Abstract decorator class for a DocIdSet implementation
+            that provides on-demand filtering/validation
+            mechanism on a given DocIdSet.
+            
+            <p/>
+            
+            Technically, this same functionality could be achieved
+            with ChainedFilter (under contrib/misc), however the
+            benefit of this class is it never materializes the full
+            bitset for the filter.  Instead, the {@link #match}
+            method is invoked on-demand, per docID visited during
+            searching.  If you know few docIDs will be visited, and
+            the logic behind {@link #match} is relatively costly,
+            this may be a better way to filter than ChainedFilter.
+            
+            </summary>
+            <seealso cref="T:Lucene.Net.Search.DocIdSet">
+            </seealso>
         </member>
-        <member name="T:Lucene.Net.Search.Spans.SpanTermQuery">
-            <summary>Matches spans containing a term. </summary>
+        <member name="T:Lucene.Net.Search.DocIdSet">
+            <summary> A DocIdSet contains a set of doc ids. Implementing classes must
+            only implement {@link #iterator} to provide access to the set. 
+            </summary>
         </member>
-        <member name="T:Lucene.Net.Search.Spans.SpanQuery">
-            <summary>Base class for span-based queries. </summary>
+        <member name="F:Lucene.Net.Search.DocIdSet.EMPTY_DOCIDSET">
+            <summary>An empty {@code DocIdSet} instance for easy use, e.g. in Filters that hit no documents. </summary>
         </member>
-        <member name="T:Lucene.Net.Search.Query">
-            <summary>The abstract base class for queries.
-            <p/>Instantiable subclasses are:
-            <ul>
-            <li> {@link TermQuery} </li>
-            <li> {@link MultiTermQuery} </li>
-            <li> {@link BooleanQuery} </li>
-            <li> {@link WildcardQuery} </li>
-            <li> {@link PhraseQuery} </li>
-            <li> {@link PrefixQuery} </li>
-            <li> {@link MultiPhraseQuery} </li>
-            <li> {@link FuzzyQuery} </li>
-            <li> {@link TermRangeQuery} </li>
-            <li> {@link NumericRangeQuery} </li>
-            <li> {@link Lucene.Net.Search.Spans.SpanQuery} </li>
-            </ul>
-            <p/>A parser for queries is contained in:
-            <ul>
-            <li>{@link Lucene.Net.QueryParsers.QueryParser QueryParser} </li>
-            </ul>
+        <member name="M:Lucene.Net.Search.DocIdSet.Iterator">
+            <summary>Provides a {@link DocIdSetIterator} to access the set.
+            This implementation can return <code>null</code> or
+            <code>{@linkplain #EMPTY_DOCIDSET}.iterator()</code> if there
+            are no docs that match. 
             </summary>
         </member>
-        <member name="M:Lucene.Net.Search.Query.SetBoost(System.Single)">
-            <summary>Sets the boost for this query clause to <code>b</code>.  Documents
-            matching this clause will (in addition to the normal weightings) have
-            their score multiplied by <code>b</code>.
+        <member name="M:Lucene.Net.Search.DocIdSet.IsCacheable">
+            <summary>This method is a hint for {@link CachingWrapperFilter}, if this <code>DocIdSet</code>
+            should be cached without copying it into a BitSet. The default is to return
+            <code>false</code>. If you have an own <code>DocIdSet</code> implementation
+            that does its iteration very effective and fast without doing disk I/O,
+            override this method and return true.
             </summary>
         </member>
-        <member name="M:Lucene.Net.Search.Query.GetBoost">
-            <summary>Gets the boost for this clause.  Documents matching
-            this clause will (in addition to the normal weightings) have their score
-            multiplied by <code>b</code>.   The boost is 1.0 by default.
+        <member name="T:Lucene.Net.Search.DocIdSetIterator">
+            <summary> This abstract class defines methods to iterate over a set of non-decreasing
+            doc ids. Note that this class assumes it iterates on doc Ids, and therefore
+            {@link #NO_MORE_DOCS} is set to {@value #NO_MORE_DOCS} in order to be used as
+            a sentinel object. Implementations of this class are expected to consider
+            {@link Integer#MAX_VALUE} as an invalid value.
             </summary>
         </member>
-        <member name="M:Lucene.Net.Search.Query.ToString(System.String)">
-            <summary>Prints a query to a string, with <code>field</code> assumed to be the 
-            default field and omitted.
-            <p/>The representation used is one that is supposed to be readable
-            by {@link Lucene.Net.QueryParsers.QueryParser QueryParser}. However,
-            there are the following limitations:
-            <ul>
-            <li>If the query was created by the parser, the printed
-            representation may not be exactly what was parsed. For example,
-            characters that need to be escaped will be represented without
-            the required backslash.</li>
-            <li>Some of the more complicated queries (e.g. span queries)
-            don't have a representation that can be parsed by QueryParser.</li>
-            </ul>
+        <member name="F:Lucene.Net.Search.DocIdSetIterator.NO_MORE_DOCS">
+            <summary> When returned by {@link #NextDoc()}, {@link #Advance(int)} and
+            {@link #Doc()} it means there are no more docs in the iterator.
             </summary>
         </member>
-        <member name="M:Lucene.Net.Search.Query.ToString">
-            <summary>Prints a query to a string. </summary>
-        </member>
-        <member name="M:Lucene.Net.Search.Query.CreateWeight(Lucene.Net.Search.Searcher)">
-            <summary> Expert: Constructs an appropriate Weight implementation for this query.
+        <member name="M:Lucene.Net.Search.DocIdSetIterator.Doc">
+            <summary> Unsupported anymore. Call {@link #DocID()} instead. This method throws
+            {@link UnsupportedOperationException} if called.
             
-            <p/>
-            Only implemented by primitive queries, which re-write to themselves.
-            </summary>
-        </member>
-        <member name="M:Lucene.Net.Search.Query.Weight(Lucene.Net.Search.Searcher)">
-            <summary> Expert: Constructs and initializes a Weight for a top-level query.</summary>
-        </member>
-        <member name="M:Lucene.Net.Search.Query.Rewrite(Lucene.Net.Index.IndexReader)">
-            <summary>Expert: called to re-write queries into primitive queries. For example,
-            a PrefixQuery will be rewritten into a BooleanQuery that consists
-            of TermQuerys.
             </summary>
+            <deprecated> use {@link #DocID()} instead.
+            </deprecated>
         </member>
-        <member name="M:Lucene.Net.Search.Query.Combine(Lucene.Net.Search.Query[])">
-            <summary>Expert: called when re-writing queries under MultiSearcher.
+        <member name="M:Lucene.Net.Search.DocIdSetIterator.DocID">
+            <summary> Returns the following:
+            <ul>
+            <li>-1 or {@link #NO_MORE_DOCS} if {@link #NextDoc()} or
+            {@link #Advance(int)} were not called yet.</li>
+            <li>{@link #NO_MORE_DOCS} if the iterator has exhausted.</li>
+            <li>Otherwise it should return the doc ID it is currently on.</li>
+            </ul>
+            <p/>
+            <b>NOTE:</b> in 3.0, this method will become abstract.
             
-            Create a single query suitable for use by all subsearchers (in 1-1
-            correspondence with queries). This is an optimization of the OR of
-            all queries. We handle the common optimization cases of equal
-            queries and overlapping clauses of boolean OR queries (as generated
-            by MultiTermQuery.rewrite()).
-            Be careful overriding this method as queries[0] determines which
-            method will be called and is not necessarily of the same type as
-            the other queries.
             </summary>
+            <since> 2.9
+            </since>
         </member>
-        <member name="M:Lucene.Net.Search.Query.ExtractTerms(System.Collections.Hashtable)">
-            <summary> Expert: adds all terms occuring in this query to the terms set. Only
-            works if this query is in its {@link #rewrite rewritten} form.
+        <member name="M:Lucene.Net.Search.DocIdSetIterator.Next">
+            <summary> Unsupported anymore. Call {@link #NextDoc()} instead. This method throws
+            {@link UnsupportedOperationException} if called.
             
             </summary>
-            <throws>  UnsupportedOperationException if this query is not yet rewritten </throws>
+            <deprecated> use {@link #NextDoc()} instead. This will be removed in 3.0
+            </deprecated>
         </member>
-        <member name="M:Lucene.Net.Search.Query.MergeBooleanQueries(Lucene.Net.Search.BooleanQuery[])">
-            <summary>Expert: merges the clauses of a set of BooleanQuery's into a single
-            BooleanQuery.
+        <member name="M:Lucene.Net.Search.DocIdSetIterator.SkipTo(System.Int32)">
+            <summary> Unsupported anymore. Call {@link #Advance(int)} instead. This method throws
+            {@link UnsupportedOperationException} if called.
             
-            <p/>A utility for use by {@link #Combine(Query[])} implementations.
             </summary>
+            <deprecated> use {@link #Advance(int)} instead. This will be removed in 3.0
+            </deprecated>
         </member>
-        <member name="M:Lucene.Net.Search.Query.GetSimilarity(Lucene.Net.Search.Searcher)">
-            <summary>Expert: Returns the Similarity implementation to be used for this query.
-            Subclasses may override this method to specify their own Similarity
-            implementation, perhaps one that delegates through that of the Searcher.
-            By default the Searcher's Similarity implementation is returned.
-            </summary>
-        </member>
-        <member name="M:Lucene.Net.Search.Query.Clone">
-            <summary>Returns a clone of this query. </summary>
-        </member>
-        <member name="M:Lucene.Net.Search.Spans.SpanQuery.GetSpans(Lucene.Net.Index.IndexReader)">
-            <summary>Expert: Returns the matches for this query in an index.  Used internally
-            to search for spans. 
-            </summary>
-        </member>
-        <member name="M:Lucene.Net.Search.Spans.SpanQuery.GetField">
-            <summary>Returns the name of the field matched by this query.</summary>
-        </member>
-        <member name="M:Lucene.Net.Search.Spans.SpanQuery.GetTerms">
-            <summary>Returns a collection of all terms matched by this query.</summary>
-            <deprecated> use extractTerms instead
-            </deprecated>
-            <seealso cref="!:Query.ExtractTerms(Set)">
-            </seealso>
-        </member>
-        <member name="M:Lucene.Net.Search.Spans.SpanTermQuery.#ctor(Lucene.Net.Index.Term)">
-            <summary>Construct a SpanTermQuery matching the named term's spans. </summary>
-        </member>
-        <member name="M:Lucene.Net.Search.Spans.SpanTermQuery.GetTerm">
-            <summary>Return the term whose spans are matched. </summary>
-        </member>
-        <member name="M:Lucene.Net.Search.Spans.SpanTermQuery.GetTerms">
-            <summary>Returns a collection of all terms matched by this query.</summary>
-            <deprecated> use extractTerms instead
-            </deprecated>
-            <seealso cref="!:ExtractTerms(Set)">
-            </seealso>
-        </member>
-        <member name="T:Lucene.Net.Search.Spans.FieldMaskingSpanQuery">
-            <summary> <p/>Wrapper to allow {@link SpanQuery} objects participate in composite 
-            single-field SpanQueries by 'lying' about their search field. That is, 
-            the masked SpanQuery will function as normal, 
-            but {@link SpanQuery#GetField()} simply hands back the value supplied 
-            in this class's constructor.<p/>
-            
-            <p/>This can be used to support Queries like {@link SpanNearQuery} or 
-            {@link SpanOrQuery} across different fields, which is not ordinarily 
-            permitted.<p/>
+        <member name="M:Lucene.Net.Search.DocIdSetIterator.NextDoc">
+            <summary> Advances to the next document in the set and returns the doc it is
+            currently on, or {@link #NO_MORE_DOCS} if there are no more docs in the
+            set.<br/>
             
-            <p/>This can be useful for denormalized relational data: for example, when 
-            indexing a document with conceptually many 'children': <p/>
+            <b>NOTE:</b> in 3.0 this method will become abstract, following the removal
+            of {@link #Next()}. For backward compatibility it is implemented as:
             
             <pre>
-            teacherid: 1
-            studentfirstname: james
-            studentsurname: jones
-            
-            teacherid: 2
-            studenfirstname: james
-            studentsurname: smith
-            studentfirstname: sally
-            studentsurname: jones
+            public int nextDoc() throws IOException {
+            return next() ? doc() : NO_MORE_DOCS;
+            }
             </pre>
             
-            <p/>a SpanNearQuery with a slop of 0 can be applied across two 
-            {@link SpanTermQuery} objects as follows:
-            <pre>
-            SpanQuery q1  = new SpanTermQuery(new Term("studentfirstname", "james"));
-            SpanQuery q2  = new SpanTermQuery(new Term("studentsurname", "jones"));
-            SpanQuery q2m new FieldMaskingSpanQuery(q2, "studentfirstname");
-            Query q = new SpanNearQuery(new SpanQuery[]{q1, q2m}, -1, false);
-            </pre>
-            to search for 'studentfirstname:james studentsurname:jones' and find 
-            teacherid 1 without matching teacherid 2 (which has a 'james' in position 0 
-            and 'jones' in position 1). <p/>
+            <b>NOTE:</b> after the iterator has exhausted you should not call this
+            method, as it may result in unpredicted behavior.
             
-            <p/>Note: as {@link #GetField()} returns the masked field, scoring will be 
-            done using the norms of the field name supplied. This may lead to unexpected
-            scoring behaviour.<p/>
             </summary>
+            <since> 2.9
+            </since>
         </member>
-        <member name="M:Lucene.Net.Search.Spans.FieldMaskingSpanQuery.GetTerms">
-            <deprecated> use {@link #ExtractTerms(Set)} instead. 
-            </deprecated>
-        </member>
-        <member name="T:Lucene.Net.Search.ScoreDoc">
-            <summary>Expert: Returned by low-level search implementations.</summary>
-            <seealso cref="T:Lucene.Net.Search.TopDocs">
-            </seealso>
-        </member>
-        <member name="F:Lucene.Net.Search.ScoreDoc.score">
-            <summary>Expert: The score of this document for the query. </summary>
-        </member>
-        <member name="F:Lucene.Net.Search.ScoreDoc.doc">
-            <summary>Expert: A hit document's number.</summary>
-            <seealso cref="M:Lucene.Net.Search.Searcher.Doc(System.Int32)">
-            </seealso>
-        </member>
-        <member name="M:Lucene.Net.Search.ScoreDoc.#ctor(System.Int32,System.Single)">
-            <summary>Expert: Constructs a ScoreDoc. </summary>
-        </member>
-        <member name="T:Lucene.Net.Search.Function.FieldCacheSource">
-            <summary> Expert: A base class for ValueSource implementations that retrieve values for
-            a single field from the {@link Lucene.Net.Search.FieldCache FieldCache}.
-            <p/>
-            Fields used herein nust be indexed (doesn't matter if these fields are stored or not).
-            <p/> 
-            It is assumed that each such indexed field is untokenized, or at least has a single token in a document.
-            For documents with multiple tokens of the same field, behavior is undefined (It is likely that current 
-            code would use the value of one of these tokens, but this is not guaranteed).
+        <member name="M:Lucene.Net.Search.DocIdSetIterator.Advance(System.Int32)">
+            <summary> Advances to the first beyond the current whose document number is greater
+            than or equal to <i>target</i>. Returns the current document number or
+            {@link #NO_MORE_DOCS} if there are no more docs in the set.
             <p/>
-            Document with no tokens in this field are assigned the <code>Zero</code> value.    
-            
-            <p/><font color="#FF0000">
-            WARNING: The status of the <b>Search.Function</b> package is experimental. 
-            The APIs introduced here might change in the future and will not be 
-            supported anymore in such a case.</font>
-            
-            <p/><b>NOTE</b>: with the switch in 2.9 to segment-based
-            searching, if {@link #getValues} is invoked with a
-            composite (multi-segment) reader, this can easily cause
-            double RAM usage for the values in the FieldCache.  It's
-            best to switch your application to pass only atomic
-            (single segment) readers to this API.  Alternatively, for
-            a short-term fix, you could wrap your ValueSource using
-            {@link MultiValueSource}, which costs more CPU per lookup
-            but will not consume double the FieldCache RAM.<p/>
-            </summary>
-        </member>
-        <member name="T:Lucene.Net.Search.Function.ValueSource">
-            <summary> Expert: source of values for basic function queries.
-            <p/>At its default/simplest form, values - one per doc - are used as the score of that doc.
-            <p/>Values are instantiated as 
-            {@link Lucene.Net.Search.Function.DocValues DocValues} for a particular reader.
-            <p/>ValueSource implementations differ in RAM requirements: it would always be a factor
-            of the number of documents, but for each document the number of bytes can be 1, 2, 4, or 8. 
+            Behaves as if written:
             
-            <p/><font color="#FF0000">
-            WARNING: The status of the <b>Search.Function</b> package is experimental. 
-            The APIs introduced here might change in the future and will not be 
-            supported anymore in such a case.</font>
+            <pre>
+            int advance(int target) {
+            int doc;
+            while ((doc = nextDoc()) &lt; target) {
+            }
+            return doc;
+            }
+            </pre>
             
+            Some implementations are considerably more efficient than that.
+            <p/>
+            <b>NOTE:</b> certain implemenations may return a different value (each
+            time) if called several times in a row with the same target.
+            <p/>
+            <b>NOTE:</b> this method may be called with {@value #NO_MORE_DOCS} for
+            efficiency by some Scorers. If your implementation cannot efficiently
+            determine that it should exhaust, it is recommended that you check for that
+            value in each call to this method.
+            <p/>
+            <b>NOTE:</b> after the iterator has exhausted you should not call this
+            method, as it may result in unpredicted behavior.
+            <p/>
+            <b>NOTE:</b> in 3.0 this method will become abstract, following the removal
+            of {@link #SkipTo(int)}.
             
             </summary>
+            <since> 2.9
+            </since>
         </member>
-        <member name="M:Lucene.Net.Search.Function.ValueSource.GetValues(Lucene.Net.Index.IndexReader)">
-            <summary> Return the DocValues used by the function query.</summary>
-            <param name="reader">the IndexReader used to read these values.
-            If any caching is involved, that caching would also be IndexReader based.  
+        <member name="M:Lucene.Net.Search.FilteredDocIdSet.#ctor(Lucene.Net.Search.DocIdSet)">
+            <summary> Constructor.</summary>
+            <param name="innerSet">Underlying DocIdSet
             </param>
-            <throws>  IOException for any error. </throws>
         </member>
-        <member name="M:Lucene.Net.Search.Function.ValueSource.Description">
-            <summary> description of field, used in explain() </summary>
+        <member name="M:Lucene.Net.Search.FilteredDocIdSet.IsCacheable">
+            <summary>This DocIdSet implementation is cacheable if the inner set is cacheable. </summary>
         </member>
-        <member name="M:Lucene.Net.Search.Function.ValueSource.Equals(System.Object)">
-            <summary> Needed for possible caching of query results - used by {@link ValueSourceQuery#equals(Object)}.</summary>
-            <seealso cref="!:Object.equals(Object)">
-            </seealso>
+        <member name="M:Lucene.Net.Search.FilteredDocIdSet.Match(System.Int32)">
+            <summary> Validation method to determine whether a docid should be in the result set.</summary>
+            <param name="docid">docid to be tested
+            </param>
+            <returns> true if input docid should be in the result set, false otherwise.
+            </returns>
         </member>
-        <member name="M:Lucene.Net.Search.Function.ValueSource.GetHashCode">
-            <summary> Needed for possible caching of query results - used by {@link ValueSourceQuery#hashCode()}.</summary>
-            <seealso cref="!:Object.hashCode()">
+        <member name="M:Lucene.Net.Search.FilteredDocIdSet.Iterator">
+            <summary> Implementation of the contract to build a DocIdSetIterator.</summary>
+            <seealso cref="T:Lucene.Net.Search.DocIdSetIterator">
+            </seealso>
+            <seealso cref="T:Lucene.Net.Search.FilteredDocIdSetIterator">
             </seealso>
         </member>
-        <member name="M:Lucene.Net.Search.Function.FieldCacheSource.#ctor(System.String)">
-            <summary> Create a cached field source for the input field.  </summary>
+        <member name="T:Lucene.Net.Search.FilteredDocIdSetIterator">
+            <summary> Abstract decorator class of a DocIdSetIterator
+            implementation that provides on-demand filter/validation
+            mechanism on an underlying DocIdSetIterator.  See {@link
+            FilteredDocIdSet}.
+            </summary>
         </member>
-        <member name="M:Lucene.Net.Search.Function.FieldCacheSource.GetCachedFieldValues(Lucene.Net.Search.FieldCache,System.String,Lucene.Net.Index.IndexReader)">
-            <summary> Return cached DocValues for input field and reader.</summary>
-            <param name="cache">FieldCache so that values of a field are loaded once per reader (RAM allowing)
+        <member name="M:Lucene.Net.Search.FilteredDocIdSetIterator.#ctor(Lucene.Net.Search.DocIdSetIterator)">
+            <summary> Constructor.</summary>
+            <param name="innerIter">Underlying DocIdSetIterator.
             </param>
-            <param name="field">Field for which values are required.
+        </member>
+        <member name="M:Lucene.Net.Search.FilteredDocIdSetIterator.Match(System.Int32)">
+            <summary> Validation method to determine whether a docid should be in the result set.</summary>
+            <param name="doc">docid to be tested
             </param>
-            <seealso cref="T:Lucene.Net.Search.Function.ValueSource">
+            <returns> true if input docid should be in the result set, false otherwise.
+            </returns>
+            <seealso cref="M:Lucene.Net.Search.FilteredDocIdSetIterator.#ctor(Lucene.Net.Search.DocIdSetIterator)">
             </seealso>
         </member>
-        <member name="M:Lucene.Net.Search.Function.FieldCacheSource.CachedFieldSourceEquals(Lucene.Net.Search.Function.FieldCacheSource)">
-            <summary> Check if equals to another {@link FieldCacheSource}, already knowing that cache and field are equal.  </summary>
-            <seealso cref="!:Object.equals(java.lang.Object)">
-            </seealso>
+        <member name="M:Lucene.Net.Search.FilteredDocIdSetIterator.Doc">
+            <deprecated> use {@link #DocID()} instead. 
+            </deprecated>
         </member>
-        <member name="M:Lucene.Net.Search.Function.FieldCacheSource.CachedFieldSourceHashCode">
-            <summary> Return a hash code of a {@link FieldCacheSource}, without the hash-codes of the field 
-            and the cache (those are taken care of elsewhere).  
+        <member name="M:Lucene.Net.Search.FilteredDocIdSetIterator.Next">
+            <deprecated> use {@link #NextDoc()} instead. 
+            </deprecated>
+        </member>
+        <member name="M:Lucene.Net.Search.FilteredDocIdSetIterator.SkipTo(System.Int32)">
+            <deprecated> use {@link #Advance(int)} instead. 
+            </deprecated>
+        </member>
+        <member name="M:Lucene.Net.Search.QueryFilter.#ctor(Lucene.Net.Search.Query)">
+            <summary>Constructs a filter which only matches documents matching
+            <code>query</code>.
             </summary>
-            <seealso cref="!:Object.hashCode()">
-            </seealso>
         </member>
-        <member name="T:Lucene.Net.Search.FilteredDocIdSet">
-            <summary> Abstract decorator class for a DocIdSet implementation
-            that provides on-demand filtering/validation
-            mechanism on a given DocIdSet.
-            
-            <p/>
+        <member name="T:Lucene.Net.Search.PrefixQuery">
+            <summary>A Query that matches documents containing terms with a specified prefix. A PrefixQuery
+            is built by QueryParser for input like <code>app*</code>.
             
-            Technically, this same functionality could be achieved
-            with ChainedFilter (under contrib/misc), however the
-            benefit of this class is it never materializes the full
-            bitset for the filter.  Instead, the {@link #match}
-            method is invoked on-demand, per docID visited during
-            searching.  If you know few docIDs will be visited, and
-            the logic behind {@link #match} is relatively costly,
-            this may be a better way to filter than ChainedFilter.
+            <p/>This query uses the {@link
+            MultiTermQuery#CONSTANT_SCORE_AUTO_REWRITE_DEFAULT}
+            rewrite method. 
+            </summary>
+        </member>
+        <member name="T:Lucene.Net.Search.MultiTermQuery">
+            <summary> An abstract {@link Query} that matches documents
+            containing a subset of terms provided by a {@link
+            FilteredTermEnum} enumeration.
+            
+            <p/>This query cannot be used directly; you must subclass
+            it and define {@link #getEnum} to provide a {@link
+            FilteredTermEnum} that iterates through the terms to be
+            matched.
+            
+            <p/><b>NOTE</b>: if {@link #setRewriteMethod} is either
+            {@link #CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE} or {@link
+            #SCORING_BOOLEAN_QUERY_REWRITE}, you may encounter a
+            {@link BooleanQuery.TooManyClauses} exception during
+            searching, which happens when the number of terms to be
+            searched exceeds {@link
+            BooleanQuery#GetMaxClauseCount()}.  Setting {@link
+            #setRewriteMethod} to {@link #CONSTANT_SCORE_FILTER_REWRITE}
+            prevents this.
+            
+            <p/>The recommended rewrite method is {@link
+            #CONSTANT_SCORE_AUTO_REWRITE_DEFAULT}: it doesn't spend CPU
+            computing unhelpful scores, and it tries to pick the most
+            performant rewrite method given the query.
             
+            Note that {@link QueryParser} produces
+            MultiTermQueries using {@link
+            #CONSTANT_SCORE_AUTO_REWRITE_DEFAULT} by default.
             </summary>
-            <seealso cref="T:Lucene.Net.Search.DocIdSet">
+        </member>
+        <member name="F:Lucene.Net.Search.MultiTermQuery.CONSTANT_SCORE_FILTER_REWRITE">
+            <summary>A rewrite method that first creates a private Filter,
+            by visiting each term in sequence and marking all docs
+            for that term.  Matching documents are assigned a
+            constant score equal to the query's boost.
+            
+            <p/> This method is faster than the BooleanQuery
+            rewrite methods when the number of matched terms or
+            matched documents is non-trivial. Also, it will never
+            hit an errant {@link BooleanQuery.TooManyClauses}
+            exception.
+            
+            </summary>
+            <seealso cref="!:setRewriteMethod">
             </seealso>
         </member>
-        <member name="T:Lucene.Net.Search.DocIdSet">
-            <summary> A DocIdSet contains a set of doc ids. Implementing classes must
-            only implement {@link #iterator} to provide access to the set. 
+        <member name="F:Lucene.Net.Search.MultiTermQuery.SCORING_BOOLEAN_QUERY_REWRITE">
+            <summary>A rewrite method that first translates each term into
+            {@link BooleanClause.Occur#SHOULD} clause in a
+            BooleanQuery, and keeps the scores as computed by the
+            query.  Note that typically such scores are
+            meaningless to the user, and require non-trivial CPU
+            to compute, so it's almost always better to use {@link
+            #CONSTANT_SCORE_AUTO_REWRITE_DEFAULT} instead.
+            
+            <p/><b>NOTE</b>: This rewrite method will hit {@link
+            BooleanQuery.TooManyClauses} if the number of terms
+            exceeds {@link BooleanQuery#getMaxClauseCount}.
+            
             </summary>
+            <seealso cref="!:setRewriteMethod">
+            </seealso>
         </member>
-        <member name="F:Lucene.Net.Search.DocIdSet.EMPTY_DOCIDSET">
-            <summary>An empty {@code DocIdSet} instance for easy use, e.g. in Filters that hit no documents. </summary>
+        <member name="F:Lucene.Net.Search.MultiTermQuery.CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE">
+            <summary>Like {@link #SCORING_BOOLEAN_QUERY_REWRITE} except
+            scores are not computed.  Instead, each matching
+            document receives a constant score equal to the
+            query's boost.
+            
+            <p/><b>NOTE</b>: This rewrite method will hit {@link
+            BooleanQuery.TooManyClauses} if the number of terms
+            exceeds {@link BooleanQuery#getMaxClauseCount}.
+            
+            </summary>
+            <seealso cref="!:setRewriteMethod">
+            </seealso>
         </member>
-        <member name="M:Lucene.Net.Search.DocIdSet.Iterator">
-            <summary>Provides a {@link DocIdSetIterator} to access the set.
-            This implementation can return <code>null</code> or
-            <code>{@linkplain #EMPTY_DOCIDSET}.iterator()</code> if there
-            are no docs that match. 
+        <member name="F:Lucene.Net.Search.MultiTermQuery.CONSTANT_SCORE_AUTO_REWRITE_DEFAULT">
+            <summary>Read-only default instance of {@link
+            ConstantScoreAutoRewrite}, with {@link
+            ConstantScoreAutoRewrite#setTermCountCutoff} set to
+            {@link
+            ConstantScoreAutoRewrite#DEFAULT_TERM_COUNT_CUTOFF}
+            and {@link
+            ConstantScoreAutoRewrite#setDocCountPercent} set to
+            {@link
+            ConstantScoreAutoRewrite#DEFAULT_DOC_COUNT_PERCENT}.

[... 47117 lines stripped ...]


Mime
View raw message