lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From thow...@apache.org
Subject [Lucene.Net] svn commit: r1074468 [6/7] - in /incubator/lucene.net/tags/Lucene.Net_2_9_2_RC1: ./ build/ contrib/Analyzers/ contrib/Analyzers/Lucene.Net.Analyzers/ contrib/Analyzers/Lucene.Net.Analyzers/AR/ contrib/Analyzers/Lucene.Net.Analyzers/Properties/ contrib/...
Date Fri, 25 Feb 2011 10:48:39 GMT
Modified: incubator/lucene.net/tags/Lucene.Net_2_9_2_RC1/src/Lucene.Net/Lucene.Net.xml
URL: http://svn.apache.org/viewvc/incubator/lucene.net/tags/Lucene.Net_2_9_2_RC1/src/Lucene.Net/Lucene.Net.xml?rev=1074468&r1=1074467&r2=1074468&view=diff
==============================================================================
--- incubator/lucene.net/tags/Lucene.Net_2_9_2_RC1/src/Lucene.Net/Lucene.Net.xml (original)
+++ incubator/lucene.net/tags/Lucene.Net_2_9_2_RC1/src/Lucene.Net/Lucene.Net.xml Fri Feb 25 10:48:35 2011
@@ -4,301 +4,298 @@
         <name>Lucene.Net</name>
     </assembly>
     <members>
-        <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.BitUtil">
-            <summary>
-            A variety of high efficiencly bit twiddling routines.
-            (from org.apache.solr.util rev 555343)
+        <member name="T:Lucene.Net.Util.Version">
+            <summary> Use by certain classes to match version compatibility
+            across releases of Lucene.
+             <p/>
+             <b>WARNING</b>: When changing the version parameter
+             that you supply to components in Lucene, do not simply
+             change the version at search-time, but instead also adjust
+             your indexing code to match, and re-index.
             </summary>
         </member>
-        <member name="M:Lucene.Net.Util.BitUtil.pop(System.Int64)">
-            Returns the number of bits set in the long 
-        </member>
-        <member name="M:Lucene.Net.Util.BitUtil.pop_intersect(System.Int64[],System.Int64[],System.Int32,System.Int32)">
-            Returns the popcount or cardinality of the two sets after an intersection.
-            Neither array is modified.
-        </member>
-        <member name="M:Lucene.Net.Util.BitUtil.pop_union(System.Int64[],System.Int64[],System.Int32,System.Int32)">
-            Returns the popcount or cardinality of the union of two sets.
-            Neither array is modified.
-        </member>
-        <!-- Badly formed XML comment ignored for member "M:Lucene.Net.Util.BitUtil.pop_andnot(System.Int64[],System.Int64[],System.Int32,System.Int32)" -->
-        <member name="F:Lucene.Net.Util.BitUtil.ntzTable">
-            table of number of trailing zeros in a byte 
+        <member name="T:Lucene.Net.Util.Parameter">
+            <summary> A serializable Enum class.</summary>
         </member>
-        <member name="M:Lucene.Net.Util.BitUtil.ntz(System.Int64)">
-            Returns number of trailing zeros in the 64 bit long value. 
+        <member name="M:Lucene.Net.Util.Parameter.ReadResolve">
+            <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.Util.BitUtil.ntz2(System.Int64)">
-            returns 0 based index of first set bit
-            (only works for x!=0)
-            <br/> This is an alternate implementation of ntz()
+        <member name="F:Lucene.Net.Util.Version.LUCENE_CURRENT">
+            <summary>
+            <p/><b>WARNING</b>: if you use this setting, and then
+            upgrade to a newer release of Lucene, sizable changes
+            may happen.  If precise back compatibility is important
+            then you should instead explicitly specify an actual
+            version.
+            If you use this constant then you may need to
+            <b>re-index all of your documents</b> when upgrading
+            Lucene, as the way text is indexed may have changed.
+            Additionally, you may need to <b>re-test your entire
+            application</b> to ensure it behaves as expected, as
+            some defaults may have changed and may break functionality
+            in your application.
+            </summary>
         </member>
-        <member name="M:Lucene.Net.Util.BitUtil.ntz3(System.Int64)">
-            returns 0 based index of first set bit
-            <br/> This is an alternate implementation of ntz()
+        <member name="F:Lucene.Net.Util.Version.LUCENE_20">
+            <summary>Match settings and bugs in Lucene's 2.0 release. </summary>
         </member>
-        <member name="M:Lucene.Net.Util.BitUtil.isPowerOfTwo(System.Int32)">
-            returns true if v is a power of two or zero
+        <member name="F:Lucene.Net.Util.Version.LUCENE_21">
+            <summary>Match settings and bugs in Lucene's 2.1 release. </summary>
         </member>
-        <member name="M:Lucene.Net.Util.BitUtil.isPowerOfTwo(System.Int64)">
-            returns true if v is a power of two or zero
+        <member name="F:Lucene.Net.Util.Version.LUCENE_22">
+            <summary>Match settings and bugs in Lucene's 2.2 release. </summary>
         </member>
-        <member name="M:Lucene.Net.Util.BitUtil.nextHighestPowerOfTwo(System.Int32)">
-            returns the next highest power of two, or the current value if it's already a power of two or zero
+        <member name="F:Lucene.Net.Util.Version.LUCENE_23">
+            <summary>Match settings and bugs in Lucene's 2.3 release. </summary>
         </member>
-        <member name="M:Lucene.Net.Util.BitUtil.nextHighestPowerOfTwo(System.Int64)">
-            returns the next highest power of two, or the current value if it's already a power of two or zero
+        <member name="F:Lucene.Net.Util.Version.LUCENE_24">
+            <summary>Match settings and bugs in Lucene's 2.3 release. </summary>
         </member>
-        <!-- Badly formed XML comment ignored for member "T:Lucene.Net.Store.VerifyingLockFactory" -->
-        <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>
-            
-            <p>Note that there are some useful tools to verify that
-            your LockFactory is working correctly: {@link
-            VerifyingLockFactory}, {@link LockStressTest}, {@link
-            LockVerifyServer}.</p>
-            
+        <!-- Badly formed XML comment ignored for member "F:Lucene.Net.Util.Version.LUCENE_29" -->
+        <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.
             </summary>
-            <seealso cref="T:Lucene.Net.Store.LockVerifyServer">
-            </seealso>
-            <seealso cref="T:Lucene.Net.Store.LockStressTest">
+            <seealso cref="T:Lucene.Net.Store.Directory">
             </seealso>
-            <seealso cref="T:Lucene.Net.Store.VerifyingLockFactory">
+            <seealso cref="T:Lucene.Net.Store.IndexInput">
             </seealso>
         </member>
-        <member name="M:Lucene.Net.Store.LockFactory.SetLockPrefix(System.String)">
-            <summary> Set the prefix in use for all locks created in this
-            LockFactory.  This is normally called once, when a
-            Directory gets this LockFactory instance.  However, you
-            can also call this (after this instance is assigned to
-            a Directory) to override the prefix in use.  This
-            is helpful if you're running Lucene on machines that
-            have different mount points for the same shared
-            directory.
-            </summary>
-        </member>
-        <member name="M:Lucene.Net.Store.LockFactory.GetLockPrefix">
-            <summary> Get the prefix in use for all locks created in this LockFactory.</summary>
+        <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>
-        <member name="M:Lucene.Net.Store.LockFactory.MakeLock(System.String)">
-            <summary> Return a new Lock instance identified by lockName.</summary>
-            <param name="lockName">name of the lock to be created.
+        <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>
-        </member>
-        <member name="M:Lucene.Net.Store.LockFactory.ClearLock(System.String)">
-            <summary> Attempt to clear (forcefully unlock and remove) the
-            specified lock.  Only call this at a time when you are
-            certain this lock is no longer in use.
-            </summary>
-            <param name="lockName">name of the lock to be cleared.
+            <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>
-        <member name="M:Lucene.Net.Store.VerifyingLockFactory.#ctor(System.Byte,Lucene.Net.Store.LockFactory,System.String,System.Int32)">
-            <param name="id">should be a unique id across all clients
-            </param>
-            <param name="lf">the LockFactory that we are testing
+        <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="host">host or IP where {@link LockVerifyServer}
-            is running
+            <param name="offset">the offset in the byte array
             </param>
-            <param name="port">the port {@link LockVerifyServer} is
-            listening on
+            <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>
-        <!-- Badly formed XML comment ignored for member "T:Lucene.Net.Store.Lock" -->
-        <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 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>
-        <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. 
+        <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.
             </summary>
+            <seealso cref="M:Lucene.Net.Store.IndexInput.ReadVInt">
+            </seealso>
         </member>
-        <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 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>
-        <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.
+        <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.
             </summary>
+            <seealso cref="M:Lucene.Net.Store.IndexInput.ReadVLong">
+            </seealso>
         </member>
-        <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.
+        <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>
+        <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).
             </summary>
-            <param name="lockWaitTimeout">length of time to wait in
-            milliseconds or {@link
-            #LOCK_OBTAIN_WAIT_FOREVER} to retry forever
+            <param name="s">the source of the characters
             </param>
-            <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.Lock.Release">
-            <summary>Releases exclusive access. </summary>
+            <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.Lock.IsLocked">
-            <summary>Returns true if the resource is currently locked.  Note that one must
-            still call {@link #Obtain()} before using the resource. 
+        <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).
             </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="T:Lucene.Net.Store.Lock.With">
-            <summary>Utility class for executing code with exclusive access. </summary>
+        <member name="M:Lucene.Net.Store.IndexOutput.CopyBytes(Lucene.Net.Store.IndexInput,System.Int64)">
+            <summary>Copy numBytes bytes from input to ourself. </summary>
         </member>
-        <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 name="M:Lucene.Net.Store.IndexOutput.Flush">
+            <summary>Forces any buffered output to be written. </summary>
         </member>
-        <member name="M:Lucene.Net.Store.Lock.With.DoBody">
-            <summary>Code to execute with exclusive access. </summary>
+        <member name="M:Lucene.Net.Store.IndexOutput.Close">
+            <summary>Closes this stream to further operations. </summary>
         </member>
-        <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
+        <member name="M:Lucene.Net.Store.IndexOutput.GetFilePointer">
+            <summary>Returns the current position in this file, where the next write will
+            occur.
             </summary>
-            <throws>  IOException if {@link Lock#obtain} throws IOException </throws>
+            <seealso cref="M:Lucene.Net.Store.IndexOutput.Seek(System.Int64)">
+            </seealso>
         </member>
-        <member name="T:Lucene.Net.Store.NoLockFactory">
-            <summary> Use this {@link LockFactory} to disable locking entirely.
-            This LockFactory is used when you call {@link FSDirectory#setDisableLocks}.
-            Only one instance of this lock is created.  You should call {@link
-            #GetNoLockFactory()} to get the instance.
-            
-            </summary>
-            <seealso cref="T:Lucene.Net.Store.LockFactory">
+        <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>
-        <member name="T:Lucene.Net.Search.Spans.SpanScorer">
-            <summary> Public for extension only.</summary>
+        <member name="M:Lucene.Net.Store.IndexOutput.Length">
+            <summary>The number of bytes in the file. </summary>
         </member>
-        <member name="T:Lucene.Net.Search.Scorer">
-            <summary> Expert: Common scoring functionality for different types of queries.
+        <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
+            </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>
+        </member>
+        <member name="T:Lucene.Net.Search.WildcardQuery">
+            <summary>Implements the wildcard search query. Supported wildcards are <code>*</code>, which
+            matches any character sequence (including the empty one), and <code>?</code>,
+            which matches any single character. Note this query can be slow, as it
+            needs to iterate over many terms. In order to prevent extremely slow WildcardQueries,
+            a Wildcard term should not start with one of the wildcards <code>*</code> or
+            <code>?</code>.
+            
+            <p/>This query uses the {@link
+            MultiTermQuery#CONSTANT_SCORE_AUTO_REWRITE_DEFAULT}
+            rewrite method.
             
-            <p>
-            A <code>Scorer</code> either iterates over documents matching a
-            query in increasing order of doc Id, or provides an explanation of
-            the score for a query for a given document.
-            </p>
-            <p>
-            Document scores are computed using a given <code>Similarity</code>
-            implementation.
-            </p>
             </summary>
-            <seealso cref="!:BooleanQuery.setAllowDocsOutOfOrder">
+            <seealso cref="T:Lucene.Net.Search.WildcardTermEnum">
             </seealso>
         </member>
-        <member name="M:Lucene.Net.Search.DocIdSetIterator.Doc">
-            <summary>
-            Returns the current document number.  This is invalid until Next() is called for the first time.
+        <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>
+        </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>
-            <returns>the current doc number</returns> 
         </member>
-        <member name="M:Lucene.Net.Search.DocIdSetIterator.Next">
-            <summary>
-            Moves to the next docId in the set.  Returns true, iff there is such a docId.
+        <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>
-            <returns>true if there is a next docId</returns>
         </member>
-        <member name="M:Lucene.Net.Search.DocIdSetIterator.SkipTo(System.Int32)">
-            <summary>
-            Skips entries to the first beyond the current whose document number is
-            greater than or equal to <i>target</i>.  Returns true iff there is such
-            an entry.
-            <p>
-            Behaves as if written:
-            <pre>
-              boolean skipTo(int target) {
-                do {
-                  if (!next())
-                    return false;
-                } while (target > doc());
-                return true;
-              }
-            </pre>
-            Some implementations are considerably more efficient than that.
-            </p>
+        <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>
-            <returns>true if there is a docId greater than or equal to target</returns>
         </member>
-        <member name="M:Lucene.Net.Search.Scorer.#ctor(Lucene.Net.Search.Similarity)">
-            <summary>Constructs a Scorer.</summary>
-            <param name="similarity">The <code>Similarity</code> implementation used by this scorer.
-            </param>
+        <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.Search.Scorer.GetSimilarity">
-            <summary>Returns the Similarity implementation used by this scorer. </summary>
+        <member name="M:Lucene.Net.Search.Query.ToString">
+            <summary>Prints a query to a string. </summary>
         </member>
-        <!-- Badly formed XML comment ignored for member "M:Lucene.Net.Search.Scorer.Score(Lucene.Net.Search.HitCollector)" -->
-        <member name="M:Lucene.Net.Search.Scorer.Score(Lucene.Net.Search.HitCollector,System.Int32)">
-            <summary>Expert: Collects matching documents in a range.  Hook for optimization.
-            Note that {@link #Next()} must be called once before this method is called
-            for the first time.
-            </summary>
-            <param name="hc">The collector to which all matching documents are passed through
-            {@link HitCollector#Collect(int, float)}.
-            </param>
-            <param name="max">Do not score documents past this.
-            </param>
-            <returns> true if more matching documents may remain.
-            </returns>
-        </member>
-        <member name="M:Lucene.Net.Search.Scorer.Score">
-            <summary>Returns the score of the current document matching the query.
-            Initially invalid, until {@link #Next()} or {@link #SkipTo(int)}
-            is called the first time.
-            </summary>
-        </member>
-        <!-- Badly formed XML comment ignored for member "M:Lucene.Net.Search.Scorer.Explain(System.Int32)" -->
-        <member name="T:Lucene.Net.Search.Spans.SpanNearQuery">
-            <summary>Matches spans which are near one another.  One can specify <i>slop</i>, the
-            maximum number of intervening unmatched positions, as well as whether
-            matches are required to be in-order. 
-            </summary>
-        </member>
-        <member name="T:Lucene.Net.Search.Spans.SpanQuery">
-            <summary>Base class for span-based queries. </summary>
-        </member>
-        <!-- Badly formed XML comment ignored for member "T:Lucene.Net.Search.Query" -->
-        <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.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="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>
         </member>
-        <!-- Badly formed XML comment ignored for member "M:Lucene.Net.Search.Query.ToString(System.String)" -->
-        <member name="M:Lucene.Net.Search.Query.ToString">
-            <summary>Prints a query to a string. </summary>
-        </member>
-        <!-- Badly formed XML comment ignored for member "M:Lucene.Net.Search.Query.CreateWeight(Lucene.Net.Search.Searcher)" -->
         <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>
+            <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,
@@ -313,7 +310,7 @@
             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() and RangeQuery.rewrite()).
+            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.
@@ -326,7 +323,13 @@
             </summary>
             <throws>  UnsupportedOperationException if this query is not yet rewritten </throws>
         </member>
-        <!-- Badly formed XML comment ignored for member "M:Lucene.Net.Search.Query.MergeBooleanQueries(Lucene.Net.Search.Query[])" -->
+        <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>
+        </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
@@ -337,4323 +340,15958 @@
         <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.GetPayloadSpans(Lucene.Net.Index.IndexReader)">
-            <summary>
-            Returns the matches for this query in an index, including access to any payloads
-            at thos positions.  Implementin classes that want access to the payloads will need
-            to implement this.
-            <para>
-            WARNING: The status of the Payloads feature is experimental.
-            The APIs introduced here might change in the future and will not be
-            supported anymore in such a cse.
-            </para>
+        <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="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.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="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}.
+            Note that you cannot alter the configuration of this
+            instance; you'll need to create a private instance
+            instead. 
             </summary>
-            <param name="reader">the reader to use to access spans/payloads</param>
-            <returns>null</returns>
         </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
+        <member name="M:Lucene.Net.Search.MultiTermQuery.#ctor(Lucene.Net.Index.Term)">
+            <summary> Constructs a query for terms matching <code>term</code>.</summary>
+            <deprecated> check sub class for possible term access - the Term does not
+            make sense for all MultiTermQuerys and will be removed.
             </deprecated>
-            <seealso cref="!:Query#ExtractTerms(Set)">
-            </seealso>
         </member>
-        <member name="M:Lucene.Net.Search.Spans.SpanNearQuery.#ctor(Lucene.Net.Search.Spans.SpanQuery[],System.Int32,System.Boolean)">
-            <summary>Construct a SpanNearQuery.  Matches spans matching a span from each
-            clause, with up to <code>slop</code> total unmatched positions between
-            them.  * When <code>inOrder</code> is true, the spans from each clause
-            must be * ordered as in <code>clauses</code>. 
+        <member name="M:Lucene.Net.Search.MultiTermQuery.#ctor">
+            <summary> Constructs a query matching terms that cannot be represented with a single
+            Term.
             </summary>
         </member>
-        <member name="M:Lucene.Net.Search.Spans.SpanNearQuery.GetClauses">
-            <summary>Return the clauses whose spans are matched. </summary>
+        <member name="M:Lucene.Net.Search.MultiTermQuery.GetTerm">
+            <summary> Returns the pattern term.</summary>
+            <deprecated> check sub class for possible term access - getTerm does not
+            make sense for all MultiTermQuerys and will be removed.
+            </deprecated>
         </member>
-        <member name="M:Lucene.Net.Search.Spans.SpanNearQuery.GetSlop">
-            <summary>Return the maximum number of intervening unmatched positions permitted.</summary>
+        <member name="M:Lucene.Net.Search.MultiTermQuery.GetEnum(Lucene.Net.Index.IndexReader)">
+            <summary>Construct the enumeration to be used, expanding the pattern term. </summary>
         </member>
-        <member name="M:Lucene.Net.Search.Spans.SpanNearQuery.IsInOrder">
-            <summary>Return true if matches are required to be in-order.</summary>
+        <member name="M:Lucene.Net.Search.MultiTermQuery.GetTotalNumberOfTerms">
+            <summary> Expert: Return the number of unique terms visited during execution of the query.
+            If there are many of them, you may consider using another query type
+            or optimize your total term count in index.
+            <p/>This method is not thread safe, be sure to only call it when no query is running!
+            If you re-use the same query instance for another
+            search, be sure to first reset the term counter
+            with {@link #clearTotalNumberOfTerms}.
+            <p/>On optimized indexes / no MultiReaders, you get the correct number of
+            unique terms for the whole index. Use this number to compare different queries.
+            For non-optimized indexes this number can also be achived in
+            non-constant-score mode. In constant-score mode you get the total number of
+            terms seeked for all segments / sub-readers.
+            </summary>
+            <seealso cref="!:clearTotalNumberOfTerms">
+            </seealso>
         </member>
-        <member name="M:Lucene.Net.Search.Spans.SpanNearQuery.GetTerms">
-            <summary>Returns a collection of all terms matched by this query.</summary>
-            <deprecated> use extractTerms instead
-            </deprecated>
-            <seealso cref="!:#ExtractTerms(Set)">
+        <member name="M:Lucene.Net.Search.MultiTermQuery.ClearTotalNumberOfTerms">
+            <summary> Expert: Resets the counting of unique terms.
+            Do this before executing the query/filter.
+            </summary>
+            <seealso cref="!:getTotalNumberOfTerms">
             </seealso>
         </member>
-        <member name="M:Lucene.Net.Search.Spans.SpanNearQuery.Equals(System.Object)">
-            <summary>Returns true iff <code>o</code> is equal to this. </summary>
+        <member name="M:Lucene.Net.Search.MultiTermQuery.GetRewriteMethod">
+            <seealso cref="!:setRewriteMethod">
+            </seealso>
         </member>
-        <member name="T:Lucene.Net.Search.SpanFilter">
-            <summary>Abstract base class providing a mechanism to restrict searches to a subset
-            of an index and also maintains and returns position information.
-            This is useful if you want to compare the positions from a SpanQuery with the positions of items in
-            a filter.  For instance, if you had a SpanFilter that marked all the occurrences of the word "foo" in documents,
-            and then you entered a new SpanQuery containing bar, you could not only filter by the word foo, but you could
-            then compare position information for post processing.
+        <member name="M:Lucene.Net.Search.MultiTermQuery.SetRewriteMethod(Lucene.Net.Search.MultiTermQuery.RewriteMethod)">
+            <summary> Sets the rewrite method to be used when executing the
+            query.  You can use one of the four core methods, or
+            implement your own subclass of {@link RewriteMethod}. 
             </summary>
         </member>
-        <member name="T:Lucene.Net.Search.Filter">
-            <summary>
-            Abstract base class providing a mechanism to limit index search results
-            to a subset of an index.
-            <para>
-            Note: In Lucene 3.0, Bits(IndexReader) will be removed and GetDocIdSet(IndexReader)
-            will be made abstract.  All implementin classes must therefore implement
-            GetDocIdSet(IndexReader) in order to work with Lucene 3.0.
-            </para>
+        <member name="T:Lucene.Net.Search.MultiTermQuery.ConstantScoreAutoRewrite">
+            <summary>A rewrite method that tries to pick the best
+            constant-score rewrite method based on term and
+            document counts from the query.  If both the number of
+            terms and documents is small enough, then {@link
+            #CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE} is used.
+            Otherwise, {@link #CONSTANT_SCORE_FILTER_REWRITE} is
+            used.
             </summary>
         </member>
-        <member name="M:Lucene.Net.Search.Filter.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="T:Lucene.Net.Search.MultiTermQuery.RewriteMethod">
+            <summary>Abstract class that defines how the query is rewritten. </summary>
         </member>
-        <member name="M:Lucene.Net.Search.Filter.GetDocIdSet(Lucene.Net.Index.IndexReader)">
-            <summary>
-            Return a DocIdSet that provides the documents which are permitted
-            or prohibited in search results.
+        <member name="M:Lucene.Net.Search.MultiTermQuery.ConstantScoreAutoRewrite.SetTermCountCutoff(System.Int32)">
+            <summary>If the number of terms in this query is equal to or
+            larger than this setting then {@link
+            #CONSTANT_SCORE_FILTER_REWRITE} is used. 
             </summary>
-            <param name="reader"></param>
-            <returns></returns>
-            <see cref="T:Lucene.Net.Util.DocIdBitSet"/>
         </member>
-        <member name="M:Lucene.Net.Search.SpanFilter.BitSpans(Lucene.Net.Index.IndexReader)">
-            <summary>Returns a SpanFilterResult with true for documents which should be permitted in
-            search results, and false for those that should not and Spans for where the true docs match.
+        <member name="M:Lucene.Net.Search.MultiTermQuery.ConstantScoreAutoRewrite.GetTermCountCutoff">
+            <seealso cref="!:setTermCountCutoff">
+            </seealso>
+        </member>
+        <member name="M:Lucene.Net.Search.MultiTermQuery.ConstantScoreAutoRewrite.SetDocCountPercent(System.Double)">
+            <summary>If the number of documents to be visited in the
+            postings exceeds this specified percentage of the
+            maxDoc() for the index, then {@link
+            #CONSTANT_SCORE_FILTER_REWRITE} is used.
             </summary>
-            <param name="reader">The {@link Lucene.Net.Index.IndexReader} to load position and DocIdSet information from
+            <param name="percent">0.0 to 100.0 
             </param>
-            <returns> A {@link SpanFilterResult}
-            </returns>
-            <throws>  java.io.IOException if there was an issue accessing the necessary information </throws>
-            <summary> 
-            </summary>
         </member>
-        <!-- Badly formed XML comment ignored for member "T:Lucene.Net.Search.QueryWrapperFilter" -->
-        <member name="M:Lucene.Net.Search.QueryWrapperFilter.#ctor(Lucene.Net.Search.Query)">
-            <summary>Constructs a filter which only matches documents matching
-            <code>query</code>.
-            </summary>
+        <member name="M:Lucene.Net.Search.MultiTermQuery.ConstantScoreAutoRewrite.GetDocCountPercent">
+            <seealso cref="!:setDocCountPercent">
+            </seealso>
         </member>
-        <!-- Badly formed XML comment ignored for member "T:Lucene.Net.Search.HitCollector" -->
-        <!-- Badly formed XML comment ignored for member "M:Lucene.Net.Search.HitCollector.Collect(System.Int32,System.Single)" -->
-        <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.
+        <member name="M:Lucene.Net.Search.WildcardQuery.GetTerm">
+            <summary> Returns the pattern term.</summary>
+        </member>
+        <member name="M:Lucene.Net.Search.WildcardQuery.ToString(System.String)">
+            <summary>Prints a user-readable version of this query. </summary>
+        </member>
+        <member name="T:Lucene.Net.Search.SortComparatorSource">
+            <summary> Expert: returns a comparator for sorting ScoreDocs.
+            
+            <p/>
+            Created: Apr 21, 2004 3:49:28 PM
+            
+            This class will be used as part of a key to a FieldCache value. You must
+            implement hashCode and equals to avoid an explosion in RAM usage if you use
+            instances that are not the same instance. If you are searching using the
+            Remote contrib, the same instance of this class on the client will be a new
+            instance on every call to the server, so hashCode/equals is very important in
+            that situation.
             
             </summary>
-            <version>  $Id: QueryFilter.java 528298 2007-04-13 00:59:28Z hossman $
+            <version>  $Id: SortComparatorSource.java 747019 2009-02-23 13:59:50Z
+            mikemccand $
             </version>
-            <deprecated> use a CachingWrapperFilter with QueryWrapperFilter
+            <since> 1.4
+            </since>
+            <deprecated> Please use {@link FieldComparatorSource} instead.
             </deprecated>
         </member>
-        <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="F:Lucene.Net.Search.CachingWrapperFilter.cache">
-            <summary> A transient Filter cache.  To cache Filters even when using {@link RemoteSearchable} use
-            {@link RemoteCachingWrapperFilter} instead.
-            </summary>
-        </member>
-        <member name="M:Lucene.Net.Search.CachingWrapperFilter.#ctor(Lucene.Net.Search.Filter)">
-            <param name="filter">Filter to cache results of
+        <member name="M:Lucene.Net.Search.SortComparatorSource.NewComparator(Lucene.Net.Index.IndexReader,System.String)">
+            <summary> Creates a comparator for the field in the given index.</summary>
+            <param name="reader">Index to create comparator for.
+            </param>
+            <param name="fieldname"> Name of the field to create comparator for.
             </param>
+            <returns> Comparator of ScoreDoc objects.
+            </returns>
+            <throws>  IOException If an error occurs reading the index. </throws>
         </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>.
+        <member name="T:Lucene.Net.Search.PhraseScorer">
+            <summary>Expert: Scoring functionality for phrase queries.
+            <br/>A document is considered matching if it contains the phrase-query terms  
+            at "valid" positons. What "valid positions" are
+            depends on the type of the phrase query: for an exact phrase query terms are required 
+            to appear in adjacent locations, while for a sloppy phrase query some distance between 
+            the terms is allowed. The abstract method {@link #PhraseFreq()} of extending classes
+            is invoked for each document containing all the phrase query terms, in order to 
+            compute the frequency of the phrase query in that document. A non zero frequency
+            means a match. 
             </summary>
         </member>
-        <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>. 
+        <member name="T:Lucene.Net.Search.Scorer">
+            <summary> Expert: Common scoring functionality for different types of queries.
+            
+            <p/>
+            A <code>Scorer</code> iterates over documents matching a
+            query in increasing order of doc Id.
+            <p/>
+            <p/>
+            Document scores are computed using a given <code>Similarity</code>
+            implementation.
+            <p/>
+            
+            <p/><b>NOTE</b>: The values Float.Nan,
+            Float.NEGATIVE_INFINITY and Float.POSITIVE_INFINITY are
+            not valid scores.  Certain collectors (eg {@link
+            TopScoreDocCollector}) will not properly collect hits
+            with these scores.
+            
             </summary>
+            <seealso cref="!:BooleanQuery.setAllowDocsOutOfOrder">
+            </seealso>
         </member>
-        <member name="M:Lucene.Net.Search.PrefixQuery.#ctor(Lucene.Net.Index.Term)">
-            <summary>Constructs a query for terms starting with <code>prefix</code>. </summary>
-        </member>
-        <member name="M:Lucene.Net.Search.PrefixQuery.GetPrefix">
-            <summary>Returns the prefix of this query. </summary>
-        </member>
-        <member name="M:Lucene.Net.Search.PrefixQuery.ToString(System.String)">
-            <summary>Prints a user-readable version of this query. </summary>
+        <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.PrefixQuery.Equals(System.Object)">
-            <summary>Returns true iff <code>o</code> is equal to this. </summary>
+        <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.PrefixQuery.GetHashCode">
-            <summary>Returns a hash code value for this object.</summary>
+        <member name="M:Lucene.Net.Search.DocIdSetIterator.Doc">
+            <summary> Unsupported anymore. Call {@link #DocID()} instead. This method throws
+            {@link UnsupportedOperationException} if called.
+            
+            </summary>
+            <deprecated> use {@link #DocID()} instead.
+            </deprecated>
         </member>
-        <!-- Badly formed XML comment ignored for member "T:Lucene.Net.Search.Hits" -->
-        <member name="M:Lucene.Net.Search.Hits.GetMoreDocs(System.Int32)">
-            <summary> Tries to add new documents to hitDocs.
-            Ensures that the hit numbered <code>min</code> has been retrieved.
+        <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.
+            
             </summary>
+            <since> 2.9
+            </since>
         </member>
-        <member name="M:Lucene.Net.Search.Hits.Length">
-            <summary>Returns the total number of hits available in this set. </summary>
+        <member name="M:Lucene.Net.Search.DocIdSetIterator.Next">
+            <summary> Unsupported anymore. Call {@link #NextDoc()} instead. This method throws
+            {@link UnsupportedOperationException} if called.
+            
+            </summary>
+            <deprecated> use {@link #NextDoc()} instead. This will be removed in 3.0
+            </deprecated>
         </member>
-        <!-- Badly formed XML comment ignored for member "M:Lucene.Net.Search.Hits.Doc(System.Int32)" -->
-        <member name="M:Lucene.Net.Search.Hits.Score(System.Int32)">
-            <summary>Returns the score for the n<sup>th</sup> document in this set. </summary>
+        <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.
+            
+            </summary>
+            <deprecated> use {@link #Advance(int)} instead. This will be removed in 3.0
+            </deprecated>
         </member>
-        <member name="M:Lucene.Net.Search.Hits.Id(System.Int32)">
-            <summary>Returns the id for the n<sup>th</sup> document in this set.
-            Note that ids may change when the index changes, so you cannot
-            rely on the id to be stable.
+        <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/>
+            
+            <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>
+            public int nextDoc() throws IOException {
+            return next() ? doc() : NO_MORE_DOCS;
+            }
+            </pre>
+            
+            <b>NOTE:</b> after the iterator has exhausted you should not call this
+            method, as it may result in unpredicted behavior.
+            
             </summary>
+            <since> 2.9
+            </since>
         </member>
-        <member name="M:Lucene.Net.Search.Hits.Iterator">
-            <summary> Returns a {@link HitIterator} to navigate the Hits.  Each item returned
-            from {@link Iterator#next()} is a {@link Hit}.
-            <p>
-            <b>Caution:</b> Iterate only over the hits needed.  Iterating over all
-            hits is generally not desirable and may be the source of
-            performance issues. If you need to iterate over many or all hits, consider
-            using a search method that takes a {@link HitCollector}.
-            </p>
+        <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/>
+            Behaves as if written:
+            
+            <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>
-        <!-- Badly formed XML comment ignored for member "T:Lucene.Net.Search.Function.OrdFieldSource" -->
-        <!-- Badly formed XML comment ignored for member "T:Lucene.Net.Search.Function.ValueSource" -->
-        <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.Scorer.#ctor(Lucene.Net.Search.Similarity)">
+            <summary>Constructs a Scorer.</summary>
+            <param name="similarity">The <code>Similarity</code> implementation used by this scorer.
             </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.Scorer.GetSimilarity">
+            <summary>Returns the Similarity implementation used by this scorer. </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.Scorer.Score(Lucene.Net.Search.HitCollector)">
+            <summary>Scores and collects all matching documents.</summary>
+            <param name="hc">The collector to which all matching documents are passed through
+            {@link HitCollector#Collect(int, float)}.
+            <br/>When this method is used the {@link #Explain(int)} method should not be used.
+            </param>
+            <deprecated> use {@link #Score(Collector)} instead.
+            </deprecated>
         </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()">
-            </seealso>
+        <member name="M:Lucene.Net.Search.Scorer.Score(Lucene.Net.Search.Collector)">
+            <summary>Scores and collects all matching documents.</summary>
+            <param name="collector">The collector to which all matching documents are passed.
+            <br/>When this method is used the {@link #Explain(int)} method should not be used.
+            </param>
         </member>
-        <member name="M:Lucene.Net.Search.Function.OrdFieldSource.#ctor(System.String)">
-            <summary> Contructor for a certain field.</summary>
-            <param name="field">field whose values order is used.  
+        <member name="M:Lucene.Net.Search.Scorer.Score(Lucene.Net.Search.HitCollector,System.Int32)">
+            <summary>Expert: Collects matching documents in a range.  Hook for optimization.
+            Note that {@link #Next()} must be called once before this method is called
+            for the first time.
+            </summary>
+            <param name="hc">The collector to which all matching documents are passed through
+            {@link HitCollector#Collect(int, float)}.
             </param>
+            <param name="max">Do not score documents past this.
+            </param>
+            <returns> true if more matching documents may remain.
+            </returns>
+            <deprecated> use {@link #Score(Collector, int, int)} instead.
+            </deprecated>
         </member>
-        <!-- Badly formed XML comment ignored for member "T:Lucene.Net.Search.Function.DocValues" -->
-        <!-- Badly formed XML comment ignored for member "M:Lucene.Net.Search.Function.DocValues.FloatVal(System.Int32)" -->
-        <!-- Badly formed XML comment ignored for member "M:Lucene.Net.Search.Function.DocValues.IntVal(System.Int32)" -->
-        <!-- Badly formed XML comment ignored for member "M:Lucene.Net.Search.Function.DocValues.LongVal(System.Int32)" -->
-        <!-- Badly formed XML comment ignored for member "M:Lucene.Net.Search.Function.DocValues.DoubleVal(System.Int32)" -->
-        <!-- Badly formed XML comment ignored for member "M:Lucene.Net.Search.Function.DocValues.StrVal(System.Int32)" -->
-        <member name="M:Lucene.Net.Search.Function.DocValues.ToString(System.Int32)">
-            <summary> Return a string representation of a doc value, as reuired for Explanations.</summary>
-        </member>
-        <member name="M:Lucene.Net.Search.Function.DocValues.Explain(System.Int32)">
-            <summary> Explain the scoring value for the input doc.</summary>
+        <member name="M:Lucene.Net.Search.Scorer.Score(Lucene.Net.Search.Collector,System.Int32,System.Int32)">
+            <summary> Expert: Collects matching documents in a range. Hook for optimization.
+            Note, <code>firstDocID</code> is added to ensure that {@link #NextDoc()}
+            was called before this method.
+            
+            </summary>
+            <param name="collector">The collector to which all matching documents are passed.
+            </param>
+            <param name="max">Do not score documents past this.
+            </param>
+            <param name="firstDocID">
+            The first document ID (ensures {@link #NextDoc()} is called before
+            this method.
+            </param>
+            <returns> true if more matching documents may remain.
+            </returns>
         </member>
-        <!-- Badly formed XML comment ignored for member "M:Lucene.Net.Search.Function.DocValues.GetInnerArray" -->
-        <member name="M:Lucene.Net.Search.Function.DocValues.GetMinValue">
-            <summary> Optional op.
-            Returns the minimum of all values.
+        <member name="M:Lucene.Net.Search.Scorer.Score">
+            <summary>Returns the score of the current document matching the query.
+            Initially invalid, until {@link #Next()} or {@link #SkipTo(int)}
+            is called the first time, or when called from within
+            {@link Collector#collect}.
             </summary>
         </member>
-        <member name="M:Lucene.Net.Search.Function.DocValues.GetMaxValue">
-            <summary> Optional op.
-            Returns the maximum of all values. 
+        <member name="M:Lucene.Net.Search.Scorer.Explain(System.Int32)">
+            <summary>Returns an explanation of the score for a document.
+            <br/>When this method is used, the {@link #Next()}, {@link #SkipTo(int)} and
+            {@link #Score(HitCollector)} methods should not be used.
             </summary>
+            <param name="doc">The document number for the explanation.
+            
+            </param>
+            <deprecated> Please use {@link IndexSearcher#explain}
+            or {@link Weight#explain} instead.
+            </deprecated>
         </member>
-        <member name="M:Lucene.Net.Search.Function.DocValues.GetAverageValue">
-            <summary> Returns the average of all values. </summary>
+        <member name="M:Lucene.Net.Search.PhraseScorer.Doc">
+            <deprecated> use {@link #DocID()} instead. 
+            </deprecated>
         </member>
-        <!-- Badly formed XML comment ignored for member "T:Lucene.Net.Search.ConstantScoreRangeQuery" -->
-        <member name="M:Lucene.Net.Search.ConstantScoreRangeQuery.GetField">
-            <summary>Returns the field name for this query </summary>
+        <member name="M:Lucene.Net.Search.PhraseScorer.Next">
+            <deprecated> use {@link #NextDoc()} instead. 
+            </deprecated>
         </member>
-        <member name="M:Lucene.Net.Search.ConstantScoreRangeQuery.GetLowerVal">
-            <summary>Returns the value of the lower endpoint of this range query, null if open ended </summary>
+        <member name="M:Lucene.Net.Search.PhraseScorer.SkipTo(System.Int32)">
+            <deprecated> use {@link #Advance(int)} instead. 
+            </deprecated>
         </member>
-        <member name="M:Lucene.Net.Search.ConstantScoreRangeQuery.GetUpperVal">
-            <summary>Returns the value of the upper endpoint of this range query, null if open ended </summary>
+        <member name="M:Lucene.Net.Search.PhraseScorer.PhraseFreq">
+            <summary> For a document containing all the phrase query terms, compute the
+            frequency of the phrase in that document. 
+            A non zero frequency means a match.
+            <br/>Note, that containing all phrase terms does not guarantee a match - they have to be found in matching locations.  
+            </summary>
+            <returns> frequency of the phrase in current doc, 0 if not found. 
+            </returns>
+        </member>
+        <member name="M:Lucene.Net.Search.SloppyPhraseScorer.PhraseFreq">
+            <summary> Score a candidate doc for all slop-valid position-combinations (matches) 
+            encountered while traversing/hopping the PhrasePositions.
+            <br/> The score contribution of a match depends on the distance: 
+            <br/> - highest score for distance=0 (exact match).
+            <br/> - score gets lower as distance gets higher.
+            <br/>Example: for query "a b"~2, a document "x a b a y" can be scored twice: 
+            once for "a b" (distance=0), and once for "b a" (distance=2).
+            <br/>Possibly not all valid combinations are encountered, because for efficiency  
+            we always propagate the least PhrasePosition. This allows to base on 
+            PriorityQueue and move forward faster. 
+            As result, for example, document "a b c b a"
+            would score differently for queries "a b c"~4 and "c b a"~4, although 
+            they really are equivalent. 
+            Similarly, for doc "a b c b a f g", query "c b"~2 
+            would get same score as "g f"~2, although "c b"~2 could be matched twice.
+            We may want to fix this in the future (currently not, for performance reasons).
+            </summary>
+        </member>
+        <member name="M:Lucene.Net.Search.SloppyPhraseScorer.InitPhrasePositions">
+            <summary> Init PhrasePositions in place.
+            There is a one time initialization for this scorer:
+            <br/>- Put in repeats[] each pp that has another pp with same position in the doc.
+            <br/>- Also mark each such pp by pp.repeats = true.
+            <br/>Later can consult with repeats[] in termPositionsDiffer(pp), making that check efficient.
+            In particular, this allows to score queries with no repetitions with no overhead due to this computation.
+            <br/>- Example 1 - query with no repetitions: "ho my"~2
+            <br/>- Example 2 - query with repetitions: "ho my my"~2
+            <br/>- Example 3 - query with repetitions: "my ho my"~2
+            <br/>Init per doc w/repeats in query, includes propagating some repeating pp's to avoid false phrase detection.  
+            </summary>
+            <returns> end (max position), or -1 if any term ran out (i.e. done) 
+            </returns>
+            <throws>  IOException  </throws>
         </member>
-        <member name="M:Lucene.Net.Search.ConstantScoreRangeQuery.IncludesLower">
-            <summary>Returns <code>true</code> if the lower endpoint is inclusive </summary>
+        <member name="M:Lucene.Net.Search.SloppyPhraseScorer.TermPositionsDiffer(Lucene.Net.Search.PhrasePositions)">
+            <summary> We disallow two pp's to have the same TermPosition, thereby verifying multiple occurrences 
+            in the query of the same word would go elsewhere in the matched doc.
+            </summary>
+            <returns> null if differ (i.e. valid) otherwise return the higher offset PhrasePositions
+            out of the first two PPs found to not differ.
+            </returns>
         </member>
-        <member name="M:Lucene.Net.Search.ConstantScoreRangeQuery.IncludesUpper">
-            <summary>Returns <code>true</code> if the upper endpoint is inclusive </summary>
+        <member name="T:Lucene.Net.Util.PriorityQueue">
+            <summary>A PriorityQueue maintains a partial ordering of its elements such that the
+            least element can always be found in constant time.  Put()'s and pop()'s
+            require log(size) time.
+            
+            <p/><b>NOTE</b>: This class pre-allocates a full array of
+            length <code>maxSize+1</code>, in {@link #initialize}.
+            
+            </summary>
         </member>
-        <member name="M:Lucene.Net.Search.ConstantScoreRangeQuery.ToString(System.String)">
-            <summary>Prints a user-readable version of this query. </summary>
+        <member name="M:Lucene.Net.Util.PriorityQueue.LessThan(System.Object,System.Object)">
+            <summary>Determines the ordering of objects in this priority queue.  Subclasses
+            must define this one method. 
+            </summary>
         </member>
-        <member name="M:Lucene.Net.Search.ConstantScoreRangeQuery.Equals(System.Object)">
-            <summary>Returns true if <code>o</code> is equal to this. </summary>
+        <member name="M:Lucene.Net.Util.PriorityQueue.GetSentinelObject">
+            <summary> This method can be overridden by extending classes to return a sentinel
+            object which will be used by {@link #Initialize(int)} to fill the queue, so
+            that the code which uses that queue can always assume it's full and only
+            change the top without attempting to insert any new object.<br/>
+            
+            Those sentinel values should always compare worse than any non-sentinel
+            value (i.e., {@link #LessThan(Object, Object)} should always favor the
+            non-sentinel values).<br/>
+            
+            By default, this method returns false, which means the queue will not be
+            filled with sentinel values. Otherwise, the value returned will be used to
+            pre-populate the queue. Adds sentinel values to the queue.<br/>
+            
+            If this method is extended to return a non-null value, then the following
+            usage pattern is recommended:
+            
+            <pre>
+            // extends getSentinelObject() to return a non-null value.
+            PriorityQueue pq = new MyQueue(numHits);
+            // save the 'top' element, which is guaranteed to not be null.
+            MyObject pqTop = (MyObject) pq.top();
+            &lt;...&gt;
+            // now in order to add a new element, which is 'better' than top (after 
+            // you've verified it is better), it is as simple as:
+            pqTop.change().
+            pqTop = pq.updateTop();
+            </pre>
+            
+            <b>NOTE:</b> if this method returns a non-null value, it will be called by
+            {@link #Initialize(int)} {@link #Size()} times, relying on a new object to
+            be returned and will not check if it's null again. Therefore you should
+            ensure any call to this method creates a new instance and behaves
+            consistently, e.g., it cannot return null if it previously returned
+            non-null.
+            
+            </summary>
+            <returns> the sentinel object to use to pre-populate the queue, or null if
+            sentinel objects are not supported.
+            </returns>
         </member>
-        <member name="M:Lucene.Net.Search.ConstantScoreRangeQuery.GetHashCode">
-            <summary>Returns a hash code value for this object.</summary>
+        <member name="M:Lucene.Net.Util.PriorityQueue.Initialize(System.Int32)">
+            <summary>Subclass constructors must call this. </summary>
         </member>
-        <member name="M:Lucene.Net.Index.DocFieldConsumerPerField.processFields(Lucene.Net.Documents.Fieldable[],System.Int32)">
-            <summary>
-            Processes all occurrences of a single field
+        <member name="M:Lucene.Net.Util.PriorityQueue.Put(System.Object)">
+            <summary> Adds an Object to a PriorityQueue in log(size) time. If one tries to add
+            more objects than maxSize from initialize a RuntimeException
+            (ArrayIndexOutOfBound) is thrown.
+            
             </summary>
-            <param name="fields"></param>
-            <param name="count"></param>
+            <deprecated> use {@link #Add(Object)} which returns the new top object,
+            saving an additional call to {@link #Top()}.
+            </deprecated>
         </member>
-        <member name="M:Lucene.Net.Index.DocFieldConsumer.flush(System.Collections.Generic.IDictionary{System.Object,System.Collections.Generic.ICollection{System.Object}},Lucene.Net.Index.DocumentsWriter.FlushState)">
-            <summary>
-            Called when DocumentsWriter decides to create a new
-            segment
+        <member name="M:Lucene.Net.Util.PriorityQueue.Add(System.Object)">
+            <summary> Adds an Object to a PriorityQueue in log(size) time. If one tries to add
+            more objects than maxSize from initialize an
+            {@link ArrayIndexOutOfBoundsException} is thrown.
+            
             </summary>
+            <returns> the new 'top' element in the queue.
+            </returns>
         </member>
-        <member name="M:Lucene.Net.Index.DocFieldConsumer.closeDocStore(Lucene.Net.Index.DocumentsWriter.FlushState)">
-            <summary>
-            Called when DocumentsWriter decides to close the doc
-            stores
+        <member name="M:Lucene.Net.Util.PriorityQueue.Insert(System.Object)">
+            <summary> Adds element to the PriorityQueue in log(size) time if either the
+            PriorityQueue is not full, or not lessThan(element, top()).
+            
             </summary>
+            <param name="element">
+            </param>
+            <returns> true if element is added, false otherwise.
+            </returns>
+            <deprecated> use {@link #InsertWithOverflow(Object)} instead, which
+            encourages objects reuse.
+            </deprecated>
         </member>
-        <member name="M:Lucene.Net.Index.DocFieldConsumer.Abort">
-            <summary>
-            Called when an aborting exception is hit
+        <member name="M:Lucene.Net.Util.PriorityQueue.InsertWithOverflow(System.Object)">
+            <summary> insertWithOverflow() is the same as insert() except its
+            return value: it returns the object (if any) that was
+            dropped off the heap because it was full. This can be
+            the given parameter (in case it is smaller than the
+            full heap's minimum, and couldn't be added), or another
+            object that was previously the smallest value in the
+            heap and now has been replaced by a larger one, or null
+            if the queue wasn't yet full with maxSize elements.
             </summary>
         </member>
-        <member name="M:Lucene.Net.Index.DocFieldConsumer.addThread(Lucene.Net.Index.DocFieldProcessorPerThread)">
-            <summary>
-            Add a new thread
+        <member name="M:Lucene.Net.Util.PriorityQueue.Top">
+            <summary>Returns the least element of the PriorityQueue in constant time. </summary>
+        </member>
+        <member name="M:Lucene.Net.Util.PriorityQueue.Pop">
+            <summary>Removes and returns the least element of the PriorityQueue in log(size)
+            time. 
             </summary>
         </member>
-        <member name="M:Lucene.Net.Index.DocFieldConsumer.freeRAM">
-            <summary>
-            Called when DocumentsWriter is using too much RAM.
-            The consumer should free RAM, if possible, returning
-            true if any RAM was in fact freed.
+        <member name="M:Lucene.Net.Util.PriorityQueue.AdjustTop">
+            <summary> Should be called when the Object at top changes values. Still log(n) worst
+            case, but it's at least twice as fast to
+            
+            <pre>
+            pq.top().change();
+            pq.adjustTop();
+            </pre>
+            
+            instead of
+            
+            <pre>
+            o = pq.pop();
+            o.change();
+            pq.push(o);
+            </pre>
+            
             </summary>
+            <deprecated> use {@link #UpdateTop()} which returns the new top element and
+            saves an additional call to {@link #Top()}.
+            </deprecated>
         </member>
-        <member name="T:Lucene.Net.Index.DocumentsWriter.DocWriter">
-            Consumer returns this on each doc.  This holds any
-            state that must be flushed synchronized "in docID
-            order".  We gather these and flush them in order. 
+        <member name="M:Lucene.Net.Util.PriorityQueue.UpdateTop">
+            <summary> Should be called when the Object at top changes values. Still log(n) worst
+            case, but it's at least twice as fast to
+            
+            <pre>
+            pq.top().change();
+            pq.updateTop();
+            </pre>
+            
+            instead of
+            
+            <pre>
+            o = pq.pop();
+            o.change();
+            pq.push(o);
+            </pre>
+            
+            </summary>
+            <returns> the new 'top' element.
+            </returns>
         </member>
-        <member name="T:Lucene.Net.Index.DocumentsWriter">
-                 * This class accepts multiple added documents and directly
-                 * writes a single segment file.  It does this more
-                 * efficiently than creating a single segment per document
-                 * (with DocumentWriter) and doing standard merges on those
-                 * segments.
-                 *
-                 * Each added document is passed to the {@link DocConsumer},
-                 * which in turn processes the document and interacts with
-                 * other consumers in the indexing chain.  Certain
-                 * consumers, like {@link StoredFieldsWriter} and {@link
-                 * TermVectorsTermsWriter}, digest a document and
-                 * immediately write bytes to the "doc store" files (ie,
-                 * they do not consume RAM per document, except while they
-                 * are processing the document).
-                 *
-                 * Other consumers, eg {@link FreqProxTermsWriter} and
-                 * {@link NormsWriter}, buffer bytes in RAM and flush only
-                 * when a new segment is produced.
-            
-                 * Once we have used our allowed RAM buffer, or the number
-                 * of added docs is large enough (in the case we are
-                 * flushing by doc count instead of RAM usage), we create a
-                 * real segment and flush it to the Directory.
-                 *
-                 * Threads:
-                 *
-                 * Multiple threads are allowed into addDocument at once.
-                 * There is an initial synchronized call to getThreadState
-                 * which allocates a ThreadState for this thread.  The same
-                 * thread will get the same ThreadState over time (thread
-                 * affinity) so that if there are consistent patterns (for
-                 * example each thread is indexing a different content
-                 * source) then we make better use of RAM.  Then
-                 * processDocument is called on that ThreadState without
-                 * synchronization (most of the "heavy lifting" is in this
-                 * call).  Finally the synchronized "finishDocument" is
-                 * called to flush changes to the directory.
-                 *
-                 * When flush is called by IndexWriter, or, we flush
-                 * internally when autoCommit=false, we forcefully idle all
-                 * threads and flush only once they are all idle.  This
-                 * means you can call flush with a given thread even while
-                 * other threads are actively adding/deleting documents.
-                 *
-                 *
-                 * Exceptions:
-                 *
-                 * Because this class directly updates in-memory posting
-                 * lists, and flushes stored fields and term vectors
-                 * directly to files in the directory, there are certain
-                 * limited times when an exception can corrupt this state.
-                 * For example, a disk full while flushing stored fields
-                 * leaves this file in a corrupt state.  Or, an OOM
-                 * exception while appending to the in-memory posting lists
-                 * can corrupt that posting list.  We call such exceptions
-                 * "aborting exceptions".  In these cases we must call
-                 * abort() to discard all docs added since the last flush.
-                 *
-                 * All other exceptions ("non-aborting exceptions") can
-                 * still partially update the index structures.  These
-                 * updates are consistent, but, they represent only a part
-                 * of the document seen up until the exception was hit.
-                 * When this happens, we immediately mark the document as
-                 * deleted so that the document is always atomically ("all
-                 * or none") added to the index.
+        <member name="M:Lucene.Net.Util.PriorityQueue.Size">
+            <summary>Returns the number of elements currently stored in the PriorityQueue. </summary>
         </member>
-        <member name="M:Lucene.Net.Index.DocumentsWriter.HasProx">
-            Returns true if any of the fields in the current
-            buffered docs have omitTf==false 
+        <member name="M:Lucene.Net.Util.PriorityQueue.Clear">
+            <summary>Removes all entries from the PriorityQueue. </summary>
         </member>
-        <member name="M:Lucene.Net.Index.DocumentsWriter.SetInfoStream(System.IO.TextWriter)">
-            If non-null, various details of indexing are printed
-            here. 
+        <member name="T:Lucene.Net.Search.Payloads.BoostingTermQuery">
+            <summary> The BoostingTermQuery is very similar to the {@link Lucene.Net.Search.Spans.SpanTermQuery} except
+            that it factors in the value of the payload located at each of the positions where the
+            {@link Lucene.Net.Index.Term} occurs.
+            <p/>
+            In order to take advantage of this, you must override {@link Lucene.Net.Search.Similarity#ScorePayload(String, byte[],int,int)}
+            which returns 1 by default.
+            <p/>
+            Payload scores are averaged across term occurrences in the document.  
+            
+            </summary>
+            <seealso cref="M:Lucene.Net.Search.Similarity.ScorePayload(System.String,System.Byte[],System.Int32,System.Int32)">
+            
+            </seealso>
+            <deprecated> See {@link Lucene.Net.Search.Payloads.PayloadTermQuery}
+            </deprecated>
         </member>
-        <member name="M:Lucene.Net.Index.DocumentsWriter.SetRAMBufferSizeMB(System.Double)">
-            Set how much RAM we can use before flushing. 
+        <member name="T:Lucene.Net.Search.Payloads.PayloadTermQuery">
+            <summary> This class is very similar to
+            {@link Lucene.Net.Search.Spans.SpanTermQuery} except that it factors
+            in the value of the payload located at each of the positions where the
+            {@link Lucene.Net.Index.Term} occurs.
+            <p/>
+            In order to take advantage of this, you must override
+            {@link Lucene.Net.Search.Similarity#ScorePayload(String, byte[],int,int)}
+            which returns 1 by default.
+            <p/>
+            Payload scores are aggregated using a pluggable {@link PayloadFunction}.
+            
+            </summary>
         </member>
-        <member name="M:Lucene.Net.Index.DocumentsWriter.SetMaxBufferedDocs(System.Int32)">
-            Set max buffered docs, which means we will flush by
-            doc count instead of by RAM usage. 
+        <member name="T:Lucene.Net.Search.Spans.SpanTermQuery">
+            <summary>Matches spans containing a term. </summary>
         </member>
-        <member name="M:Lucene.Net.Index.DocumentsWriter.GetSegment">
-            Get current segment name we are writing. 
+        <member name="T:Lucene.Net.Search.Spans.SpanQuery">
+            <summary>Base class for span-based queries. </summary>
         </member>
-        <member name="M:Lucene.Net.Index.DocumentsWriter.GetNumDocsInRAM">
-            Returns how many docs are currently buffered in RAM. 
+        <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.Index.DocumentsWriter.GetDocStoreSegment">
-            Returns the current doc store segment we are writing
-            to.  This will be the same as segment when autoCommit
-            * is true. 
+        <member name="M:Lucene.Net.Search.Spans.SpanQuery.GetField">

[... 36384 lines stripped ...]


Mime
View raw message