lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From d...@apache.org
Subject svn commit: r800949 [2/3] - in /incubator/lucene.net/trunk/C#/src/Lucene.Net: Lucene.Net.xml Search/FieldCache.cs Search/FieldSortedHitQueue.cs Search/Function/OrdFieldSource.cs Search/Function/ReverseOrdFieldSource.cs
Date Tue, 04 Aug 2009 20:28:11 GMT

Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Lucene.Net.xml
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Lucene.Net.xml?rev=800949&r1=800948&r2=800949&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Lucene.Net.xml (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Lucene.Net.xml Tue Aug  4 20:28:11 2009
@@ -4,6 +4,54 @@
         <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)
+            </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>
+        <member name="M:Lucene.Net.Util.BitUtil.ntz(System.Int64)">
+            Returns number of trailing zeros in the 64 bit long value. 
+        </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>
+        <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>
+        <member name="M:Lucene.Net.Util.BitUtil.isPowerOfTwo(System.Int32)">
+            returns true if v is a power of two or zero
+        </member>
+        <member name="M:Lucene.Net.Util.BitUtil.isPowerOfTwo(System.Int64)">
+            returns true if v is a power of two or zero
+        </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>
+        <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>
         <!-- 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
@@ -131,125 +179,97 @@
             </summary>
             <throws>  IOException if {@link Lock#obtain} throws IOException </throws>
         </member>
-        <member name="T:Lucene.Net.Store.RAMInputStream">
-            <summary> A memory-resident {@link IndexInput} implementation.
+        <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>
-            <version>  $Id: RAMInputStream.java 598693 2007-11-27 17:01:21Z mikemccand $
-            </version>
-        </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.
-            </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 cref="T:Lucene.Net.Store.LockFactory">
             </seealso>
         </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
-            </param>
-            <seealso cref="M:Lucene.Net.Store.IndexOutput.WriteBytes(System.Byte[],System.Int32)">
-            </seealso>
+        <member name="T:Lucene.Net.Search.Spans.SpanScorer">
+            <summary> Public for extension only.</summary>
         </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.
+        <member name="T:Lucene.Net.Search.Scorer">
+            <summary> Expert: Common scoring functionality for different types of queries.
+            
+            <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>
-            <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
-            </param>
-            <param name="useBuffer">set to false if the caller will handle
-            buffering.
-            </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 cref="!:BooleanQuery.setAllowDocsOutOfOrder">
             </seealso>
         </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="M:Lucene.Net.Search.DocIdSetIterator.Doc">
+            <summary>
+            Returns the current document number.  This is invalid until Next() is called for the first time.
             </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="!:IndexOutput#WriteLong(long)">
-            </seealso>
+            <returns>the current doc number</returns> 
         </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.DocIdSetIterator.Next">
+            <summary>
+            Moves to the next docId in the set.  Returns true, iff there is such a docId.
             </summary>
+            <returns>true if there is a next docId</returns>
         </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.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>
+            </summary>
+            <returns>true if there is a docId greater than or equal to target</returns>
         </member>
-        <member name="M:Lucene.Net.Store.IndexInput.ReadChars(System.Char[],System.Int32,System.Int32)">
-            <summary>Reads UTF-8 encoded characters into an array.</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
+        <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>
-            <seealso cref="M:Lucene.Net.Store.IndexOutput.WriteChars(System.String,System.Int32,System.Int32)">
-            </seealso>
         </member>
-        <member name="M:Lucene.Net.Store.IndexInput.SkipChars(System.Int32)">
-            <summary> Expert
-            
-            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
+        <member name="M:Lucene.Net.Search.Scorer.GetSimilarity">
+            <summary>Returns the Similarity implementation used by this scorer. </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="length">The number of chars to read
+            <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.Store.IndexInput.Close">
-            <summary>Closes the stream to futher operations. </summary>
-        </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.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>
-            <seealso cref="M:Lucene.Net.Store.IndexInput.Seek(System.Int64)">
-            </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">
-            </seealso>
         </member>
-        <member name="M:Lucene.Net.Store.IndexInput.Length">
-            <summary>The number of bytes in the file. </summary>
-        </member>
-        <!-- Badly formed XML comment ignored for member "M:Lucene.Net.Store.IndexInput.Clone" -->
+        <!-- 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
@@ -322,6 +342,20 @@
             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>
+            </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>
@@ -358,89 +392,194 @@
         <member name="M:Lucene.Net.Search.Spans.SpanNearQuery.Equals(System.Object)">
             <summary>Returns true iff <code>o</code> is equal to this. </summary>
         </member>
-        <!-- Badly formed XML comment ignored for member "T:Lucene.Net.Search.Sort" -->
-        <member name="F:Lucene.Net.Search.Sort.RELEVANCE">
-            <summary> Represents sorting by computed relevance. Using this sort criteria returns
-            the same results as calling
-            {@link Searcher#Search(Query) Searcher#search()}without a sort criteria,
-            only with slightly more overhead.
+        <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.
             </summary>
         </member>
-        <member name="F:Lucene.Net.Search.Sort.INDEXORDER">
-            <summary>Represents sorting by index order. </summary>
-        </member>
-        <member name="M:Lucene.Net.Search.Sort.#ctor">
-            <summary> Sorts by computed relevance. This is the same sort criteria as calling
-            {@link Searcher#Search(Query) Searcher#search()}without a sort criteria,
-            only with slightly more overhead.
+        <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>
             </summary>
         </member>
-        <member name="M:Lucene.Net.Search.Sort.#ctor(System.String)">
-            <summary> Sorts by the terms in <code>field</code> then by index order (document
-            number). The type of value in <code>field</code> is determined
-            automatically.
-            
+        <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>
-            <seealso cref="!:SortField#AUTO">
-            </seealso>
         </member>
-        <member name="M:Lucene.Net.Search.Sort.#ctor(System.String,System.Boolean)">
-            <summary> Sorts possibly in reverse by the terms in <code>field</code> then by
-            index order (document number). The type of value in <code>field</code> is
-            determined automatically.
-            
+        <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.
             </summary>
-            <seealso cref="!:SortField#AUTO">
-            </seealso>
+            <param name="reader"></param>
+            <returns></returns>
+            <see cref="T:Lucene.Net.Util.DocIdBitSet"/>
         </member>
-        <member name="M:Lucene.Net.Search.Sort.#ctor(System.String[])">
-            <summary> Sorts in succession by the terms in each field. The type of value in
-            <code>field</code> is determined automatically.
-            
+        <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.
+            </summary>
+            <param name="reader">The {@link Lucene.Net.Index.IndexReader} to load position and DocIdSet information from
+            </param>
+            <returns> A {@link SpanFilterResult}
+            </returns>
+            <throws>  java.io.IOException if there was an issue accessing the necessary information </throws>
+            <summary> 
             </summary>
-            <seealso cref="!:SortField#AUTO">
-            </seealso>
-        </member>
-        <member name="M:Lucene.Net.Search.Sort.#ctor(Lucene.Net.Search.SortField)">
-            <summary>Sorts by the criteria in the given SortField. </summary>
         </member>
-        <member name="M:Lucene.Net.Search.Sort.#ctor(Lucene.Net.Search.SortField[])">
-            <summary>Sorts in succession by the criteria in each SortField. </summary>
+        <!-- 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>
-        <member name="M:Lucene.Net.Search.Sort.SetSort(System.String)">
-            <summary> Sets the sort to the terms in <code>field</code> then by index order
-            (document number).
+        <!-- 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.
+            
             </summary>
+            <version>  $Id: QueryFilter.java 528298 2007-04-13 00:59:28Z hossman $
+            </version>
+            <deprecated> use a CachingWrapperFilter with QueryWrapperFilter
+            </deprecated>
         </member>
-        <member name="M:Lucene.Net.Search.Sort.SetSort(System.String,System.Boolean)">
-            <summary> Sets the sort to the terms in <code>field</code> possibly in reverse,
-            then by index order (document number).
+        <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="M:Lucene.Net.Search.Sort.SetSort(System.String[])">
-            <summary>Sets the sort to the terms in each field in succession. </summary>
+        <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.Sort.SetSort(Lucene.Net.Search.SortField)">
-            <summary>Sets the sort to the given criteria. </summary>
+        <member name="M:Lucene.Net.Search.CachingWrapperFilter.#ctor(Lucene.Net.Search.Filter)">
+            <param name="filter">Filter to cache results of
+            </param>
         </member>
-        <member name="M:Lucene.Net.Search.Sort.SetSort(Lucene.Net.Search.SortField[])">
-            <summary>Sets the sort to the given criteria in succession. </summary>
+        <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>
         </member>
-        <member name="M:Lucene.Net.Search.Sort.GetSort">
-            <summary> Representation of the sort criteria.</summary>
-            <returns> Array of SortField objects used in this sort criteria
-            </returns>
+        <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>. 
+            </summary>
         </member>
-        <member name="T:Lucene.Net.Search.Filter">
-            <summary>Abstract base class providing a mechanism to restrict searches to a subset
-            of an index. 
+        <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>
+        <member name="M:Lucene.Net.Search.PrefixQuery.Equals(System.Object)">
+            <summary>Returns true iff <code>o</code> is equal to this. </summary>
+        </member>
+        <member name="M:Lucene.Net.Search.PrefixQuery.GetHashCode">
+            <summary>Returns a hash code value for this object.</summary>
+        </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.
             </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. 
+        <member name="M:Lucene.Net.Search.Hits.Length">
+            <summary>Returns the total number of hits available in this set. </summary>
+        </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>
+        <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.
+            </summary>
+        </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>
+            </summary>
+        </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.  
+            </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>
+        <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>
+        <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>
+        <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.  
+            </param>
+        </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>
+        <!-- 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.
+            </summary>
+        </member>
+        <member name="M:Lucene.Net.Search.Function.DocValues.GetMaxValue">
+            <summary> Optional op.
+            Returns the maximum of all values. 
             </summary>
         </member>
+        <member name="M:Lucene.Net.Search.Function.DocValues.GetAverageValue">
+            <summary> Returns the average of all values. </summary>
+        </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>
@@ -466,2038 +605,1548 @@
         <member name="M:Lucene.Net.Search.ConstantScoreRangeQuery.GetHashCode">
             <summary>Returns a hash code value for this object.</summary>
         </member>
-        <member name="T:Lucene.Net.QueryParsers.Token">
-            <summary> Describes the input token stream.</summary>
-        </member>
-        <member name="F:Lucene.Net.QueryParsers.Token.kind">
-            <summary> An integer that describes the kind of this token.  This numbering
-            system is determined by JavaCCParser, and a table of these numbers is
-            stored in the file ...Constants.java.
+        <member name="M:Lucene.Net.Index.DocFieldConsumerPerField.processFields(Lucene.Net.Documents.Fieldable[],System.Int32)">
+            <summary>
+            Processes all occurrences of a single field
             </summary>
+            <param name="fields"></param>
+            <param name="count"></param>
         </member>
-        <member name="F:Lucene.Net.QueryParsers.Token.beginLine">
-            <summary> beginLine and beginColumn describe the position of the first character
-            of this token; endLine and endColumn describe the position of the
-            last character of this token.
-            </summary>
+        <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
+            </summary>
+        </member>
+        <member name="M:Lucene.Net.Index.DocFieldConsumer.closeDocStore(Lucene.Net.Index.DocumentsWriter.FlushState)">
+            <summary>
+            Called when DocumentsWriter decides to close the doc
+            stores
+            </summary>
+        </member>
+        <member name="M:Lucene.Net.Index.DocFieldConsumer.Abort">
+            <summary>
+            Called when an aborting exception is hit
+            </summary>
+        </member>
+        <member name="M:Lucene.Net.Index.DocFieldConsumer.addThread(Lucene.Net.Index.DocFieldProcessorPerThread)">
+            <summary>
+            Add a new thread
+            </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.
+            </summary>
+        </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>
+        <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>
+        <member name="M:Lucene.Net.Index.DocumentsWriter.HasProx">
+            Returns true if any of the fields in the current
+            buffered docs have omitTf==false 
         </member>
-        <member name="F:Lucene.Net.QueryParsers.Token.beginColumn">
-            <summary> beginLine and beginColumn describe the position of the first character
-            of this token; endLine and endColumn describe the position of the
-            last character of this token.
-            </summary>
+        <member name="M:Lucene.Net.Index.DocumentsWriter.SetInfoStream(System.IO.TextWriter)">
+            If non-null, various details of indexing are printed
+            here. 
         </member>
-        <member name="F:Lucene.Net.QueryParsers.Token.endLine">
-            <summary> beginLine and beginColumn describe the position of the first character
-            of this token; endLine and endColumn describe the position of the
-            last character of this token.
-            </summary>
+        <member name="M:Lucene.Net.Index.DocumentsWriter.SetRAMBufferSizeMB(System.Double)">
+            Set how much RAM we can use before flushing. 
         </member>
-        <member name="F:Lucene.Net.QueryParsers.Token.endColumn">
-            <summary> beginLine and beginColumn describe the position of the first character
-            of this token; endLine and endColumn describe the position of the
-            last character of this token.
-            </summary>
+        <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>
-        <member name="F:Lucene.Net.QueryParsers.Token.image">
-            <summary> The string image of the token.</summary>
+        <member name="M:Lucene.Net.Index.DocumentsWriter.GetSegment">
+            Get current segment name we are writing. 
         </member>
-        <member name="F:Lucene.Net.QueryParsers.Token.next">
-            <summary> A reference to the next regular (non-special) token from the input
-            stream.  If this is the last token from the input stream, or if the
-            token manager has not read tokens beyond this one, this field is
-            set to null.  This is true only if this token is also a regular
-            token.  Otherwise, see below for a description of the contents of
-            this field.
-            </summary>
+        <member name="M:Lucene.Net.Index.DocumentsWriter.GetNumDocsInRAM">
+            Returns how many docs are currently buffered in RAM. 
         </member>
-        <member name="F:Lucene.Net.QueryParsers.Token.specialToken">
-            <summary> This field is used to access special tokens that occur prior to this
-            token, but after the immediately preceding regular (non-special) token.
-            If there are no such special tokens, this field is set to null.
-            When there are more than one such special token, this field refers
-            to the last of these special tokens, which in turn refers to the next
-            previous special token through its specialToken field, and so on
-            until the first special token (whose specialToken field is null).
-            The next fields of special tokens refer to other special tokens that
-            immediately follow it (without an intervening regular token).  If there
-            is no such token, this field is null.
-            </summary>
+        <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>
-        <member name="M:Lucene.Net.QueryParsers.Token.ToString">
-            <summary> Returns the image.</summary>
+        <member name="M:Lucene.Net.Index.DocumentsWriter.GetDocStoreOffset">
+            Returns the doc offset into the shared doc store for
+            the current buffered docs. 
         </member>
-        <member name="M:Lucene.Net.QueryParsers.Token.NewToken(System.Int32)">
-            <summary> Returns a new Token object, by default. However, if you want, you
-            can create and return subclass objects based on the value of ofKind.
-            Simply add the cases to the switch for all those special cases.
-            For example, if you have a subclass of Token called IDToken that
-            you want to create if ofKind is ID, simlpy add something like :
-            
-            case MyParserConstants.ID : return new IDToken();
-            
-            to the following switch statement. Then you can cast matchedToken
-            variable to the appropriate type and use it in your lexical actions.
-            </summary>
+        <member name="M:Lucene.Net.Index.DocumentsWriter.CloseDocStore">
+            Closes the current open doc stores an returns the doc
+            store segment name.  This returns null if there are *
+            no buffered documents. 
         </member>
-        <member name="T:Lucene.Net.Index.SortedTermVectorMapper">
-            <summary> Store a sorted collection of {@link Lucene.Net.Index.TermVectorEntry}s.  Collects all term information
-            into a single, SortedSet.
-            <br/>
-            NOTE: This Mapper ignores all Field information for the Document.  This means that if you are using offset/positions you will not
-            know what Fields they correlate with.
-            <br/>
-            This is not thread-safe  
-            </summary>
+        <member name="M:Lucene.Net.Index.DocumentsWriter.Abort">
+            Called if we hit an exception at a bad time (when
+            updating the index files) and must discard all
+            currently buffered docs.  This resets our state,
+            discarding any docs added since last flush. 
         </member>
-        <member name="T:Lucene.Net.Index.TermVectorMapper">
-            <summary> The TermVectorMapper can be used to map Term Vectors into your own
-            structure instead of the parallel array structure used by
-            {@link Lucene.Net.Index.IndexReader#GetTermFreqVector(int,String)}.
-            <p/>
-            It is up to the implementation to make sure it is thread-safe.
-            
-            
-            
-            </summary>
+        <member name="M:Lucene.Net.Index.DocumentsWriter.DoAfterFlush">
+            Reset after a flush 
         </member>
-        <member name="M:Lucene.Net.Index.TermVectorMapper.#ctor(System.Boolean,System.Boolean)">
-            <summary> </summary>
-            <param name="ignoringPositions">true if this mapper should tell Lucene to ignore positions even if they are stored
-            </param>
-            <param name="ignoringOffsets">similar to ignoringPositions
-            </param>
+        <member name="M:Lucene.Net.Index.DocumentsWriter.Flush(System.Boolean)">
+            Flush all pending docs to a new segment 
         </member>
-        <member name="M:Lucene.Net.Index.TermVectorMapper.SetExpectations(System.String,System.Int32,System.Boolean,System.Boolean)">
-            <summary> Tell the mapper what to expect in regards to field, number of terms, offset and position storage.
-            This method will be called once before retrieving the vector for a field.
-            
-            This method will be called before {@link #Map(String,int,TermVectorOffsetInfo[],int[])}.
-            </summary>
-            <param name="field">The field the vector is for
-            </param>
-            <param name="numTerms">The number of terms that need to be mapped
-            </param>
-            <param name="storeOffsets">true if the mapper should expect offset information
-            </param>
-            <param name="storePositions">true if the mapper should expect positions info
-            </param>
+        <member name="M:Lucene.Net.Index.DocumentsWriter.CreateCompoundFile(System.String)">
+            Build compound file for the segment we just flushed 
         </member>
-        <member name="M:Lucene.Net.Index.TermVectorMapper.Map(System.String,System.Int32,Lucene.Net.Index.TermVectorOffsetInfo[],System.Int32[])">
-            <summary> Map the Term Vector information into your own structure</summary>
-            <param name="term">The term to add to the vector
-            </param>
-            <param name="frequency">The frequency of the term in the document
-            </param>
-            <param name="offsets">null if the offset is not specified, otherwise the offset into the field of the term
-            </param>
-            <param name="positions">null if the position is not specified, otherwise the position in the field of the term
-            </param>
+        <member name="M:Lucene.Net.Index.DocumentsWriter.SetFlushPending">
+            Set flushPending if it is not already set and returns
+            whether it was set. This is used by IndexWriter to
+            trigger a single flush even when multiple threads are
+            trying to do so. 
         </member>
-        <member name="M:Lucene.Net.Index.TermVectorMapper.IsIgnoringPositions">
-            <summary> Indicate to Lucene that even if there are positions stored, this mapper is not interested in them and they
-            can be skipped over.  Derived classes should set this to true if they want to ignore positions.  The default
-            is false, meaning positions will be loaded if they are stored.
-            </summary>
-            <returns> false
-            </returns>
+        <member name="M:Lucene.Net.Index.DocumentsWriter.GetThreadState(Lucene.Net.Documents.Document,Lucene.Net.Index.Term)">
+            Returns a free (idle) ThreadState that may be used for
+            indexing this one document.  This call also pauses if a
+            flush is pending.  If delTerm is non-null then we
+            buffer this deleted term after the thread state has
+            been acquired. 
         </member>
-        <member name="M:Lucene.Net.Index.TermVectorMapper.IsIgnoringOffsets">
-            <summary> </summary>
-            <seealso cref="!:IsIgnoringPositions() Same principal as &lt;@link #IsIgnoringPositions()&gt;, but applied to offsets.  false by default.">
-            </seealso>
-            <returns> false
-            </returns>
+        <member name="M:Lucene.Net.Index.DocumentsWriter.AddDocument(Lucene.Net.Documents.Document,Lucene.Net.Analysis.Analyzer)">
+            Returns true if the caller (IndexWriter) should now
+            flush. 
         </member>
-        <member name="M:Lucene.Net.Index.TermVectorMapper.SetDocumentNumber(System.Int32)">
-            <summary> Passes down the index of the document whose term vector is currently being mapped,
-            once for each top level call to a term vector reader.
-            <p/>
-            Default implementation IGNORES the document number.  Override if your implementation needs the document number.
-            <p/> 
-            NOTE: Document numbers are internal to Lucene and subject to change depending on indexing operations.
-            
-            </summary>
-            <param name="documentNumber">index of document currently being mapped
-            </param>
+        <member name="M:Lucene.Net.Index.DocumentsWriter.RemapDeletes(Lucene.Net.Index.SegmentInfos,System.Int32[][],System.Int32[],Lucene.Net.Index.MergePolicy.OneMerge,System.Int32)">
+            Called whenever a merge has completed and the merged segments had deletions 
         </member>
-        <member name="F:Lucene.Net.Index.SortedTermVectorMapper.ALL">
-            <summary> Stand-in name for the field in {@link TermVectorEntry}.</summary>
+        <member name="M:Lucene.Net.Index.DocumentsWriter.FinishDocument(Lucene.Net.Index.DocumentsWriterThreadState,Lucene.Net.Index.DocumentsWriter.DocWriter)">
+            Does the synchronized work to finish/flush the
+            inverted document. 
         </member>
-        <member name="M:Lucene.Net.Index.SortedTermVectorMapper.#ctor(System.Collections.Generic.IComparer{System.Object})">
-            <summary> </summary>
-            <param name="comparator">A Comparator for sorting {@link TermVectorEntry}s
-            </param>
+        <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>
+        <member name="T:Lucene.Net.Index.ByteBlockPool">
+            <summary>
+             Class that Posting and PostingVector use to write byte
+             streams into shared fixed-size byte[] arrays.  The idea
+             is to allocate slices of increasing lengths For
+             example, the first slice is 5 bytes, the next slice is
+             14, etc.  We start by writing our bytes into the first
+             5 bytes.  When we hit the end of the slice, we allocate
+             the next slice and then write the address of the new
+             slice into the last 4 bytes of the previous slice (the
+             "forwarding address").
+            
+             Each slice is filled with 0's initially, and we mark
+             the end with a non-zero byte.  This way the methods
+             that are writing into the slice don't need to record
+             its length and instead allocate a new slice once they
+             hit a non-zero byte.
+            </summary>
         </member>
-        <member name="M:Lucene.Net.Index.SortedTermVectorMapper.Map(System.String,System.Int32,Lucene.Net.Index.TermVectorOffsetInfo[],System.Int32[])">
-            <summary> </summary>
-            <param name="term">The term to map
-            </param>
-            <param name="frequency">The frequency of the term
-            </param>
-            <param name="offsets">Offset information, may be null
-            </param>
-            <param name="positions">Position information, may be null
-            </param>
+        <!-- Badly formed XML comment ignored for member "T:Lucene.Net.Documents.Document" -->
+        <member name="M:Lucene.Net.Documents.Document.#ctor">
+            <summary>Constructs a new document with no fields. </summary>
         </member>
-        <member name="M:Lucene.Net.Index.SortedTermVectorMapper.GetTermVectorEntrySet">
-            <summary> The TermVectorEntrySet.  A SortedSet of {@link TermVectorEntry} objects.  Sort is by the comparator passed into the constructor.
-            <br/>
-            This set will be empty until after the mapping process takes place.
-            
+        <member name="M:Lucene.Net.Documents.Document.GetFieldsCount">
+            <summary>Returns the number of fields in this document</summary>
+            Added as a helper for Lucene.Net
+        </member>
+        <!-- Badly formed XML comment ignored for member "M:Lucene.Net.Documents.Document.SetBoost(System.Single)" -->
+        <!-- Badly formed XML comment ignored for member "M:Lucene.Net.Documents.Document.GetBoost" -->
+        <member name="M:Lucene.Net.Documents.Document.Add(Lucene.Net.Documents.Fieldable)">
+            <summary> <p>Adds a field to a document.  Several fields may be added with
+            the same name.  In this case, if the fields are indexed, their text is
+            treated as though appended for the purposes of search.</p>
+            <p> Note that add like the removeField(s) methods only makes sense 
+            prior to adding a document to an index. These methods cannot
+            be used to change the content of an existing index! In order to achieve this,
+            a document has to be deleted from an index and a new changed version of that
+            document has to be added.</p>
             </summary>
-            <returns> The SortedSet of {@link TermVectorEntry}.
-            </returns>
         </member>
-        <member name="F:Lucene.Net.Index.SegmentInfos.FORMAT">
-            <summary>The file format version, a negative number. </summary>
+        <member name="M:Lucene.Net.Documents.Document.RemoveField(System.String)">
+            <summary> <p>Removes field with the specified name from the document.
+            If multiple fields exist with this name, this method removes the first field that has been added.
+            If there is no field with the specified name, the document remains unchanged.</p>
+            <p> Note that the removeField(s) methods like the add method only make sense 
+            prior to adding a document to an index. These methods cannot
+            be used to change the content of an existing index! In order to achieve this,
+            a document has to be deleted from an index and a new changed version of that
+            document has to be added.</p>
+            </summary>
         </member>
-        <member name="F:Lucene.Net.Index.SegmentInfos.FORMAT_LOCKLESS">
-            <summary>This format adds details used for lockless commits.  It differs
-            slightly from the previous format in that file names
-            are never re-used (write once).  Instead, each file is
-            written to the next generation.  For example,
-            segments_1, segments_2, etc.  This allows us to not use
-            a commit lock.  See <a
-            href="http://lucene.apache.org/java/docs/fileformats.html">file
-            formats</a> for details.
+        <member name="M:Lucene.Net.Documents.Document.RemoveFields(System.String)">
+            <summary> <p>Removes all fields with the given name from the document.
+            If there is no field with the specified name, the document remains unchanged.</p>
+            <p> Note that the removeField(s) methods like the add method only make sense 
+            prior to adding a document to an index. These methods cannot
+            be used to change the content of an existing index! In order to achieve this,
+            a document has to be deleted from an index and a new changed version of that
+            document has to be added.</p>
             </summary>
         </member>
-        <member name="F:Lucene.Net.Index.SegmentInfos.FORMAT_SINGLE_NORM_FILE">
-            <summary>This format adds a "hasSingleNormFile" flag into each segment info.
-            See <a href="http://issues.apache.org/jira/browse/LUCENE-756">LUCENE-756</a>
-            for details.
+        <member name="M:Lucene.Net.Documents.Document.GetField(System.String)">
+            <summary>Returns a field with the given name if any exist in this document, or
+            null.  If multiple fields exists with this name, this method returns the
+            first value added.
+            Do not use this method with lazy loaded fields.
             </summary>
         </member>
-        <member name="F:Lucene.Net.Index.SegmentInfos.FORMAT_SHARED_DOC_STORE">
-            <summary>This format allows multiple segments to share a single
-            vectors and stored fields file. 
+        <member name="M:Lucene.Net.Documents.Document.GetFieldable(System.String)">
+            <summary>Returns a field with the given name if any exist in this document, or
+            null.  If multiple fields exists with this name, this method returns the
+            first value added.
             </summary>
         </member>
-        <member name="F:Lucene.Net.Index.SegmentInfos.version">
-            <summary> counts how often the index has been changed by adding or deleting docs.
-            starting with the current time in milliseconds forces to create unique version numbers.
+        <member name="M:Lucene.Net.Documents.Document.Get(System.String)">
+            <summary>Returns the string value of the field with the given name if any exist in
+            this document, or null.  If multiple fields exist with this name, this
+            method returns the first value added. If only binary fields with this name
+            exist, returns null.
             </summary>
         </member>
-        <member name="F:Lucene.Net.Index.SegmentInfos.infoStream">
-            <summary> If non-null, information about loading segments_N files</summary>
-            <seealso cref="!:setInfoStream.">
-            </seealso>
+        <member name="M:Lucene.Net.Documents.Document.Fields">
+            <summary>Returns an Enumeration of all the fields in a document.</summary>
+            <deprecated> use {@link #GetFields()} instead
+            </deprecated>
         </member>
-        <member name="M:Lucene.Net.Index.SegmentInfos.GetCurrentSegmentGeneration(System.String[])">
-            <summary> Get the generation (N) of the current segments_N file
-            from a list of files.
-            
+        <!-- Badly formed XML comment ignored for member "M:Lucene.Net.Documents.Document.GetFields" -->
+        <member name="M:Lucene.Net.Documents.Document.GetFields(System.String)">
+            <summary> Returns an array of {@link Field}s with the given name.
+            Do not use with lazy loaded fields.
+            This method returns an empty array when there are no
+            matching fields.  It never returns null.
             </summary>
-            <param name="files">-- array of file names to check
+            <param name="name">the name of the field
             </param>
+            <returns> a <code>Field[]</code> array</returns>
         </member>
-        <member name="M:Lucene.Net.Index.SegmentInfos.GetCurrentSegmentGeneration(Lucene.Net.Store.Directory)">
-            <summary> Get the generation (N) of the current segments_N file
-            in the directory.
-            
+        <member name="M:Lucene.Net.Documents.Document.GetFieldables(System.String)">
+            <summary> Returns an array of {@link Fieldable}s with the given name.
+            This method returns an empty array when there are no
+            matching fields.  It never returns null.
             </summary>
-            <param name="directory">-- directory to search for the latest segments_N file
+            <param name="name">the name of the field
             </param>
+            <returns> a <code>Fieldable[]</code> array</returns>
         </member>
-        <member name="M:Lucene.Net.Index.SegmentInfos.GetCurrentSegmentFileName(System.String[])">
-            <summary> Get the filename of the current segments_N file
-            from a list of files.
-            
+        <member name="M:Lucene.Net.Documents.Document.GetValues(System.String)">
+            <summary> Returns an array of values of the field specified as the method parameter.
+            This method returns an empty array when there are no
+            matching fields.  It never returns null.
             </summary>
-            <param name="files">-- array of file names to check
+            <param name="name">the name of the field
             </param>
+            <returns> a <code>String[]</code> of field values</returns>
         </member>
-        <member name="M:Lucene.Net.Index.SegmentInfos.GetCurrentSegmentFileName(Lucene.Net.Store.Directory)">
-            <summary> Get the filename of the current segments_N file
-            in the directory.
+        <member name="M:Lucene.Net.Documents.Document.GetBinaryValues(System.String)">
+            <summary>
+            Returns an array of byte arrays for the fields that have the name
+            specified as the method parameter.
+            This method returns an empty array when there are no
+            matching fields.  It never returns null.
+            </summary>
+            <param name="name">the name of the field
+            </param>
+            <returns> a  <code>byte[][]</code> of binary field values</returns>
+        </member>
+        <member name="M:Lucene.Net.Documents.Document.GetBinaryValue(System.String)">
+            <summary> Returns an array of bytes for the first (or only) field that has the name
+            specified as the method parameter. This method will return <code>null</code>
+            if no binary fields with the specified name are available.
+            There may be non-binary fields with the same name.
             
             </summary>
-            <param name="directory">-- directory to search for the latest segments_N file
+            <param name="name">the name of the field.
             </param>
+            <returns> a <code>byte[]</code> containing the binary field value or <code>null</code>
+            </returns>
         </member>
-        <member name="M:Lucene.Net.Index.SegmentInfos.GetCurrentSegmentFileName">
-            <summary> Get the segments_N filename in use by this segment infos.</summary>
+        <member name="M:Lucene.Net.Documents.Document.ToString">
+            <summary>Prints the fields of a document for human consumption. </summary>
         </member>
-        <member name="M:Lucene.Net.Index.SegmentInfos.GenerationFromSegmentsFileName(System.String)">
-            <summary> Parse the generation off the segments file name and
-            return it.
+        <member name="T:Lucene.Net.Analysis.SimpleAnalyzer">
+            <summary>An Analyzer that filters LetterTokenizer with LowerCaseFilter. </summary>
+        </member>
+        <!-- Badly formed XML comment ignored for member "T:Lucene.Net.Analysis.Analyzer" -->
+        <member name="M:Lucene.Net.Analysis.Analyzer.TokenStream(System.String,System.IO.TextReader)">
+            <summary>Creates a TokenStream which tokenizes all the text in the provided
+            Reader.  Must be able to handle null field name for backward compatibility. 
             </summary>
         </member>
-        <member name="M:Lucene.Net.Index.SegmentInfos.GetNextSegmentFileName">
-            <summary> Get the next segments_N filename that will be written.</summary>
+        <member name="M:Lucene.Net.Analysis.Analyzer.ReusableTokenStream(System.String,System.IO.TextReader)">
+            <summary>Creates a TokenStream that is allowed to be re-used
+            from the previous time that the same thread called
+            this method.  Callers that do not need to use more
+            than one TokenStream at the same time from this
+            analyzer should use this method for better
+            performance.
+            </summary>
         </member>
-        <member name="M:Lucene.Net.Index.SegmentInfos.Read(Lucene.Net.Store.Directory,System.String)">
-            <summary> Read a particular segmentFileName.  Note that this may
-            throw an IOException if a commit is in process.
+        <member name="M:Lucene.Net.Analysis.Analyzer.GetPreviousTokenStream">
+            <summary>Used by Analyzers that implement reusableTokenStream
+            to retrieve previously saved TokenStreams for re-use
+            by the same thread. 
+            </summary>
+        </member>
+        <member name="M:Lucene.Net.Analysis.Analyzer.SetPreviousTokenStream(System.Object)">
+            <summary>Used by Analyzers that implement reusableTokenStream
+            to save a TokenStream for later re-use by the same
+            thread. 
+            </summary>
+        </member>
+        <member name="M:Lucene.Net.Analysis.Analyzer.GetPositionIncrementGap(System.String)">
+            <summary> Invoked before indexing a Fieldable instance if
+            terms have already been added to that field.  This allows custom
+            analyzers to place an automatic position increment gap between
+            Fieldable instances using the same field name.  The default value
+            position increment gap is 0.  With a 0 position increment gap and
+            the typical default token position increment of 1, all terms in a field,
+            including across Fieldable instances, are in successive positions, allowing
+            exact PhraseQuery matches, for instance, across Fieldable instance boundaries.
             
             </summary>
-            <param name="directory">-- directory containing the segments file
-            </param>
-            <param name="segmentFileName">-- segment file to load
+            <param name="fieldName">Fieldable name being indexed.
             </param>
-            <throws>  CorruptIndexException if the index is corrupt </throws>
-            <throws>  IOException if there is a low-level IO error </throws>
+            <returns> position increment gap, added to the next token emitted from {@link #TokenStream(String,Reader)}
+            </returns>
         </member>
-        <member name="M:Lucene.Net.Index.SegmentInfos.Read(Lucene.Net.Store.Directory)">
-            <summary> This version of read uses the retry logic (for lock-less
-            commits) to find the right segments file to load.
+        <member name="T:Lucene.Net.Analysis.KeywordAnalyzer">
+            <summary> "Tokenizes" the entire stream as a single token. This is useful
+            for data like zip codes, ids, and some product names.
             </summary>
-            <throws>  CorruptIndexException if the index is corrupt </throws>
-            <throws>  IOException if there is a low-level IO error </throws>
         </member>
-        <member name="M:Lucene.Net.Index.SegmentInfos.Clone">
-            <summary> Returns a copy of this instance, also copying each
-            SegmentInfo.
+        <member name="T:Lucene.Net.Util.OpenBitSet">
+            <summary>
+            An "open" BitSet implementation that allows direct access to the array of words
+            storing the bits.
+            <p/>
+            Unlike java.util.bitset, the fact that bits are packed into an array of longs
+            is part of the interface.  This allows efficient implementation of other algorithms
+            by someone other than the author.  It also allows one to efficiently implement
+            alternate serialization or interchange formats.
+            <p/>
+            <code>OpenBitSet</code> is faster than <code>java.util.BitSet</code> in most operations
+            and *much* faster at calculating cardinality of sets and results of set operations.
+            It can also handle sets of larger cardinality (up to 64 * 2**32-1)
+            <p/>
+            The goals of <code>OpenBitSet</code> are the fastest implementation possible, and
+            maximum code reuse.  Extra safety and encapsulation
+            may always be built on top, but if that's built in, the cost can never be removed (and
+            hence people re-implement their own version in order to get better performance).
+            If you want a "safe", totally encapsulated (and slower and limited) BitSet
+            class, use <code>java.util.BitSet</code>.
+            <p/>
+            <h3>Performance Results</h3>
             </summary>
         </member>
-        <member name="M:Lucene.Net.Index.SegmentInfos.GetVersion">
-            <summary> version number when this SegmentInfos was generated.</summary>
+        <member name="T:Lucene.Net.Search.DocIdSet">
+            <summary>
+            A DocIdSet contains a set of doc ids.  Implementing classes
+            must provide a DocIdSetIterator to access the set.
+            </summary>
         </member>
-        <member name="M:Lucene.Net.Index.SegmentInfos.ReadCurrentVersion(Lucene.Net.Store.Directory)">
-            <summary> Current version number from segments file.</summary>
-            <throws>  CorruptIndexException if the index is corrupt </throws>
-            <throws>  IOException if there is a low-level IO error </throws>
+        <member name="M:Lucene.Net.Util.OpenBitSet.#ctor(System.Int64)">
+            Constructs an OpenBitSet large enough to hold numBits.
+            
+             @param numBits
         </member>
-        <member name="M:Lucene.Net.Index.SegmentInfos.SetInfoStream(System.IO.StreamWriter)">
-            <summary>If non-null, information about retries when loading
-            the segments file will be printed to this.
-            </summary>
+        <!-- Badly formed XML comment ignored for member "M:Lucene.Net.Util.OpenBitSet.#ctor(System.Int64[],System.Int32)" -->
+        <member name="M:Lucene.Net.Util.OpenBitSet.Capacity">
+            Returns the current capacity in bits (1 greater than the index of the last bit) 
         </member>
-        <member name="M:Lucene.Net.Index.SegmentInfos.SetDefaultGenFileRetryCount(System.Int32)">
-            <summary> Advanced: set how many times to try loading the
-            segments.gen file contents to determine current segment
-            generation.  This file is only referenced when the
-            primary method (listing the directory) fails.
-            </summary>
+        <member name="M:Lucene.Net.Util.OpenBitSet.Size">
+            Returns the current capacity of this set.  Included for
+            compatibility.  This is *not* equal to {@link #cardinality}
         </member>
-        <member name="M:Lucene.Net.Index.SegmentInfos.GetDefaultGenFileRetryCount">
-            <seealso cref="!:setDefaultGenFileRetryCount">
-            </seealso>
+        <member name="M:Lucene.Net.Util.OpenBitSet.IsEmpty">
+            Returns true if there are no set bits 
         </member>
-        <member name="M:Lucene.Net.Index.SegmentInfos.SetDefaultGenFileRetryPauseMsec(System.Int32)">
-            <summary> Advanced: set how many milliseconds to pause in between
-            attempts to load the segments.gen file.
-            </summary>
+        <member name="M:Lucene.Net.Util.OpenBitSet.GetBits">
+            Expert: returns the long[] storing the bits 
         </member>
-        <member name="M:Lucene.Net.Index.SegmentInfos.GetDefaultGenFileRetryPauseMsec">
-            <seealso cref="!:setDefaultGenFileRetryPauseMsec">
-            </seealso>
-        </member>
-        <member name="M:Lucene.Net.Index.SegmentInfos.SetDefaultGenLookaheadCount(System.Int32)">
-            <summary> Advanced: set how many times to try incrementing the
-            gen when loading the segments file.  This only runs if
-            the primary (listing directory) and secondary (opening
-            segments.gen file) methods fail to find the segments
-            file.
-            </summary>
-        </member>
-        <member name="M:Lucene.Net.Index.SegmentInfos.GetDefaultGenLookahedCount">
-            <seealso cref="!:setDefaultGenLookaheadCount">
-            </seealso>
+        <member name="M:Lucene.Net.Util.OpenBitSet.SetBits(System.Int64[])">
+            Expert: sets a new long[] to use as the bit storage 
         </member>
-        <member name="M:Lucene.Net.Index.SegmentInfos.GetInfoStream">
-            <seealso cref="!:setInfoStream">
-            </seealso>
+        <member name="M:Lucene.Net.Util.OpenBitSet.GetNumWords">
+            Expert: gets the number of longs in the array that are in use 
         </member>
-        <member name="M:Lucene.Net.Index.SegmentInfos.Range(System.Int32,System.Int32)">
-            <summary> Returns a new SegmentInfos containg the SegmentInfo
-            instances in the specified range first (inclusive) to
-            last (exclusive), so total number of segments returned
-            is last-first.
-            </summary>
+        <member name="M:Lucene.Net.Util.OpenBitSet.SetNumWords(System.Int32)">
+            Expert: sets the number of longs in the array that are in use 
         </member>
-        <member name="T:Lucene.Net.Index.SegmentInfos.FindSegmentsFile">
-            <summary> Utility class for executing code that needs to do
-            something with the current segments file.  This is
-            necessary with lock-less commits because from the time
-            you locate the current segments file name, until you
-            actually open it, read its contents, or check modified
-            time, etc., it could have been deleted due to a writer
-            commit finishing.
-            </summary>
+        <member name="M:Lucene.Net.Util.OpenBitSet.Get(System.Int32)">
+            Returns true or false for the specified bit index. 
         </member>
-        <member name="M:Lucene.Net.Index.SegmentInfos.FindSegmentsFile.DoBody(System.String)">
-            <summary> Subclass must implement this.  The assumption is an
-            IOException will be thrown if something goes wrong
-            during the processing that could have been caused by
-            a writer committing.
-            </summary>
+        <member name="M:Lucene.Net.Util.OpenBitSet.FastGet(System.Int32)">
+            Returns true or false for the specified bit index.
+            The index should be less than the OpenBitSet size
         </member>
-        <member name="T:Lucene.Net.Index.IndexFileNameFilter">
-            <summary> Filename filter that accept filenames and extensions only created by Lucene.
-            
-            </summary>
-            <author>  Daniel Naber / Bernhard Messer
-            </author>
-            <version>  $rcs = ' $Id: Exp $ ' ;
-            </version>
+        <member name="M:Lucene.Net.Util.OpenBitSet.Get(System.Int64)">
+            Returns true or false for the specified bit index
         </member>
-        <member name="M:Lucene.Net.Index.IndexFileNameFilter.IsCFSFile(System.String)">
-            <summary> Returns true if this is a file that would be contained
-            in a CFS file.  This function should only be called on
-            files that pass the above "accept" (ie, are already
-            known to be a Lucene index file).
-            </summary>
+        <member name="M:Lucene.Net.Util.OpenBitSet.FastGet(System.Int64)">
+            Returns true or false for the specified bit index.
+            The index should be less than the OpenBitSet size.
         </member>
-        <member name="T:Lucene.Net.Index.FieldInfos">
-            <summary>Access to the Fieldable Info file that describes document fields and whether or
-            not they are indexed. Each segment has a separate Fieldable Info file. Objects
-            of this class are thread-safe for multiple readers, but only one thread can
-            be adding documents at a time, with no other reader or writer threads
-            accessing this object.
-            </summary>
+        <member name="M:Lucene.Net.Util.OpenBitSet.GetBit(System.Int32)">
+            returns 1 if the bit is set, 0 if not.
+            The index should be less than the OpenBitSet size
         </member>
-        <member name="M:Lucene.Net.Index.FieldInfos.#ctor(Lucene.Net.Store.Directory,System.String)">
-            <summary> Construct a FieldInfos object using the directory and the name of the file
-            IndexInput
-            </summary>
-            <param name="d">The directory to open the IndexInput from
-            </param>
-            <param name="name">The name of the file to open the IndexInput from in the Directory
-            </param>
-            <throws>  IOException </throws>
+        <member name="M:Lucene.Net.Util.OpenBitSet.Set(System.Int64)">
+            sets a bit, expanding the set size if necessary 
         </member>
-        <member name="M:Lucene.Net.Index.FieldInfos.Clone">
-            <summary> Returns a deep clone of this FieldInfos instance.</summary>
+        <member name="M:Lucene.Net.Util.OpenBitSet.FastSet(System.Int32)">
+            Sets the bit at the specified index.
+            The index should be less than the OpenBitSet size.
         </member>
-        <member name="M:Lucene.Net.Index.FieldInfos.Add(Lucene.Net.Documents.Document)">
-            <summary>Adds field info for a Document. </summary>
+        <member name="M:Lucene.Net.Util.OpenBitSet.FastSet(System.Int64)">
+            Sets the bit at the specified index.
+            The index should be less than the OpenBitSet size.
         </member>
-        <member name="M:Lucene.Net.Index.FieldInfos.AddIndexed(System.Collections.ICollection,System.Boolean,System.Boolean,System.Boolean)">
-            <summary> Add fields that are indexed. Whether they have termvectors has to be specified.
+        <member name="M:Lucene.Net.Util.OpenBitSet.Set(System.Int64,System.Int64)">
+            Sets a range of bits, expanding the set size if necessary
             
-            </summary>
-            <param name="names">The names of the fields
-            </param>
-            <param name="storeTermVectors">Whether the fields store term vectors or not
-            </param>
-            <param name="storePositionWithTermVector">treu if positions should be stored.
-            </param>
-            <param name="storeOffsetWithTermVector">true if offsets should be stored
-            </param>
+             @param startIndex lower index
+             @param endIndex one-past the last bit to set
         </member>
-        <member name="M:Lucene.Net.Index.FieldInfos.Add(System.Collections.ICollection,System.Boolean)">
-            <summary> Assumes the fields are not storing term vectors.
-            
-            </summary>
-            <param name="names">The names of the fields
-            </param>
-            <param name="isIndexed">Whether the fields are indexed or not
-            
-            </param>
-            <seealso cref="!:Add(String, boolean)">
-            </seealso>
+        <member name="M:Lucene.Net.Util.OpenBitSet.FastClear(System.Int32)">
+            clears a bit.
+            The index should be less than the OpenBitSet size.
         </member>
-        <member name="M:Lucene.Net.Index.FieldInfos.Add(System.String,System.Boolean)">
-            <summary> Calls 5 parameter add with false for all TermVector parameters.
-            
-            </summary>
-            <param name="name">The name of the Fieldable
-            </param>
-            <param name="isIndexed">true if the field is indexed
-            </param>
-            <seealso cref="!:Add(String, boolean, boolean, boolean, boolean)">
-            </seealso>
+        <member name="M:Lucene.Net.Util.OpenBitSet.FastClear(System.Int64)">
+            clears a bit.
+            The index should be less than the OpenBitSet size.
         </member>
-        <member name="M:Lucene.Net.Index.FieldInfos.Add(System.String,System.Boolean,System.Boolean)">
-            <summary> Calls 5 parameter add with false for term vector positions and offsets.
-            
-            </summary>
-            <param name="name">The name of the field
-            </param>
-            <param name="isIndexed"> true if the field is indexed
-            </param>
-            <param name="storeTermVector">true if the term vector should be stored
-            </param>
+        <member name="M:Lucene.Net.Util.OpenBitSet.Clear(System.Int64)">
+            clears a bit, allowing access beyond the current set size without changing the size.
         </member>
-        <member name="M:Lucene.Net.Index.FieldInfos.Add(System.String,System.Boolean,System.Boolean,System.Boolean,System.Boolean)">
-            <summary>If the field is not yet known, adds it. If it is known, checks to make
-            sure that the isIndexed flag is the same as was given previously for this
-            field. If not - marks it as being indexed.  Same goes for the TermVector
-            parameters.
+        <member name="M:Lucene.Net.Util.OpenBitSet.Clear(System.Int64,System.Int64)">
+            Clears a range of bits.  Clearing past the end does not change the size of the set.
             
-            </summary>
-            <param name="name">The name of the field
-            </param>
-            <param name="isIndexed">true if the field is indexed
-            </param>
-            <param name="storeTermVector">true if the term vector should be stored
-            </param>
-            <param name="storePositionWithTermVector">true if the term vector with positions should be stored
-            </param>
-            <param name="storeOffsetWithTermVector">true if the term vector with offsets should be stored
-            </param>
+             @param startIndex lower index
+             @param endIndex one-past the last bit to clear
         </member>
-        <member name="M:Lucene.Net.Index.FieldInfos.Add(System.String,System.Boolean,System.Boolean,System.Boolean,System.Boolean,System.Boolean)">
-            <summary>If the field is not yet known, adds it. If it is known, checks to make
-            sure that the isIndexed flag is the same as was given previously for this
-            field. If not - marks it as being indexed.  Same goes for the TermVector
-            parameters.
-            
-            </summary>
-            <param name="name">The name of the field
-            </param>
-            <param name="isIndexed">true if the field is indexed
-            </param>
-            <param name="storeTermVector">true if the term vector should be stored
-            </param>
-            <param name="storePositionWithTermVector">true if the term vector with positions should be stored
-            </param>
-            <param name="storeOffsetWithTermVector">true if the term vector with offsets should be stored
-            </param>
-            <param name="omitNorms">true if the norms for the indexed field should be omitted
-            </param>
+        <member name="M:Lucene.Net.Util.OpenBitSet.GetAndSet(System.Int32)">
+            Sets a bit and returns the previous value.
+            The index should be less than the OpenBitSet size.
         </member>
-        <member name="M:Lucene.Net.Index.FieldInfos.Add(System.String,System.Boolean,System.Boolean,System.Boolean,System.Boolean,System.Boolean,System.Boolean)">
-            <summary>If the field is not yet known, adds it. If it is known, checks to make
-            sure that the isIndexed flag is the same as was given previously for this
-            field. If not - marks it as being indexed.  Same goes for the TermVector
-            parameters.
-            
-            </summary>
-            <param name="name">The name of the field
-            </param>
-            <param name="isIndexed">true if the field is indexed
-            </param>
-            <param name="storeTermVector">true if the term vector should be stored
-            </param>
-            <param name="storePositionWithTermVector">true if the term vector with positions should be stored
-            </param>
-            <param name="storeOffsetWithTermVector">true if the term vector with offsets should be stored
-            </param>
-            <param name="omitNorms">true if the norms for the indexed field should be omitted
-            </param>
-            <param name="storePayloads">true if payloads should be stored for this field
-            </param>
+        <member name="M:Lucene.Net.Util.OpenBitSet.GetAndSet(System.Int64)">
+            Sets a bit and returns the previous value.
+            The index should be less than the OpenBitSet size.
         </member>
-        <member name="M:Lucene.Net.Index.FieldInfos.FieldName(System.Int32)">
-            <summary> Return the fieldName identified by its number.
-            
-            </summary>
-            <param name="">fieldNumber
-            </param>
-            <returns> the fieldName or an empty string when the field
-            with the given number doesn't exist.
-            </returns>
+        <member name="M:Lucene.Net.Util.OpenBitSet.FastFlip(System.Int32)">
+            flips a bit.
+            The index should be less than the OpenBitSet size.
         </member>
-        <member name="M:Lucene.Net.Index.FieldInfos.FieldInfo(System.Int32)">
-            <summary> Return the fieldinfo object referenced by the fieldNumber.</summary>
-            <param name="fieldNumber">
-            </param>
-            <returns> the FieldInfo object or null when the given fieldNumber
-            doesn't exist.
-            </returns>
+        <member name="M:Lucene.Net.Util.OpenBitSet.FastFlip(System.Int64)">
+            flips a bit.
+            The index should be less than the OpenBitSet size.
         </member>
-        <!-- Badly formed XML comment ignored for member "T:Lucene.Net.Analysis.PorterStemFilter" -->
-        <!-- Badly formed XML comment ignored for member "T:Lucene.Net.Analysis.TokenFilter" -->
-        <!-- Badly formed XML comment ignored for member "T:Lucene.Net.Analysis.TokenStream" -->
-        <member name="M:Lucene.Net.Analysis.TokenStream.Next">
-            <summary>Returns the next token in the stream, or null at EOS.
-            The returned Token is a "full private copy" (not
-            re-used across calls to next()) but will be slower
-            than calling {@link #Next(Token)} instead.. 
-            </summary>
+        <member name="M:Lucene.Net.Util.OpenBitSet.Flip(System.Int64)">
+            flips a bit, expanding the set size if necessary 
         </member>
-        <!-- Badly formed XML comment ignored for member "M:Lucene.Net.Analysis.TokenStream.Next(Lucene.Net.Analysis.Token)" -->
-        <member name="M:Lucene.Net.Analysis.TokenStream.Reset">
-            <summary>Resets this stream to the beginning. This is an
-            optional operation, so subclasses may or may not
-            implement this method. Reset() is not needed for
-            the standard indexing process. However, if the Tokens 
-            of a TokenStream are intended to be consumed more than 
-            once, it is necessary to implement reset(). 
-            </summary>
+        <member name="M:Lucene.Net.Util.OpenBitSet.FlipAndGet(System.Int32)">
+            flips a bit and returns the resulting bit value.
+            The index should be less than the OpenBitSet size.
         </member>
-        <member name="M:Lucene.Net.Analysis.TokenStream.Close">
-            <summary>Releases resources associated with this stream. </summary>
+        <member name="M:Lucene.Net.Util.OpenBitSet.FlipAndGet(System.Int64)">
+            flips a bit and returns the resulting bit value.
+            The index should be less than the OpenBitSet size.
         </member>
-        <member name="F:Lucene.Net.Analysis.TokenFilter.input">
-            <summary>The source of tokens for this filter. </summary>

[... 21208 lines stripped ...]


Mime
View raw message