Click here to Skip to main content
Click here to Skip to main content
Articles » Database » NoSQL » General » Downloads
 
Add your own
alternative version
Go to top

WCF by Example - Chapter XV - RavenDB Implementation

, 3 Feb 2013
Unit of Work and Repository RavenDB implementation example
eDirectory_WPF_Client_RavenDB-noexe.zip
eDirectory.WPF
amd64
Microsoft.VC90.CRT
Microsoft.VC90.CRT.manifest
eDirectory.sdf
eDirectory.WPF.vshost.exe.manifest
Resources
Icons
Warning.ico
x86
Microsoft.VC90.CRT
Microsoft.VC90.CRT.manifest
eDirectory_WPF_Client_RavenDB.zip
Microsoft.VC90.CRT.manifest
msvcr90.dll
sqlceca40.dll
sqlcecompact40.dll
sqlceer40EN.dll
sqlceme40.dll
sqlceqp40.dll
sqlcese40.dll
AutoMapper.dll
BouncyCastle.Crypto.dll
Common.Logging.dll
eDirectory.Common.dll
eDirectory.Domain.dll
eDirectory.Naive.dll
eDirectory.NHibernate.dll
eDirectory.RavenDB.dll
eDirectory.sdf
eDirectory.WPF.exe
eDirectory.WPF.vshost.exe
eDirectory.WPF.vshost.exe.manifest
Esent.Interop.dll
Hardcodet.Wpf.TaskbarNotification.dll
ICSharpCode.NRefactory.dll
Iesi.Collections.dll
Lucene.Net.Contrib.Spatial.dll
Lucene.Net.Contrib.SpellChecker.dll
Lucene.Net.dll
Newtonsoft.Json.dll
NHibernate.dll
NLog.dll
Raven.Abstractions.dll
Raven.Backup.exe
Raven.Client.Embedded.dll
Raven.Client.Lightweight.dll
Raven.Database.dll
Raven.Munin.dll
Raven.Smuggler.exe
Raven.Storage.Esent.dll
Raven.Storage.Managed.dll
Warning.ico
Spatial4n.Core.dll
Spring.Core.dll
System.Data.SqlServerCe.dll
WPFToolkit.dll
Microsoft.VC90.CRT.manifest
msvcr90.dll
sqlceca40.dll
sqlcecompact40.dll
sqlceer40EN.dll
sqlceme40.dll
sqlceqp40.dll
sqlcese40.dll
<?xml version="1.0"?>
<doc>
    <assembly>
        <name>Lucene.Net</name>
    </assembly>
    <members>
        <member name="T:Lucene.Net.Util.Cache.SimpleMapCache">
            <summary> Simple cache implementation that uses a HashMap to store (key, value) pairs.
            This cache is not synchronized, use {@link Cache#SynchronizedCache(Cache)}
            if needed.
            </summary>
        </member>
        <member name="T:Lucene.Net.Util.Cache.Cache">
            <summary> Base class for cache implementations.</summary>
        </member>
        <member name="M:Lucene.Net.Util.Cache.Cache.SynchronizedCache(Lucene.Net.Util.Cache.Cache)">
            <summary> Returns a thread-safe cache backed by the specified cache. 
            In order to guarantee thread-safety, all access to the backed cache must
            be accomplished through the returned cache.
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.Cache.Cache.GetSynchronizedCache">
            <summary> Called by {@link #SynchronizedCache(Cache)}. This method
            returns a {@link SynchronizedCache} instance that wraps
            this instance by default and can be overridden to return
            e. g. subclasses of {@link SynchronizedCache} or this
            in case this cache is already synchronized.
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.Cache.Cache.Put(System.Object,System.Object)">
            <summary> Puts a (key, value)-pair into the cache. </summary>
        </member>
        <member name="M:Lucene.Net.Util.Cache.Cache.Get(System.Object)">
            <summary> Returns the value for the given key. </summary>
        </member>
        <member name="M:Lucene.Net.Util.Cache.Cache.ContainsKey(System.Object)">
            <summary> Returns whether the given key is in this cache. </summary>
        </member>
        <member name="M:Lucene.Net.Util.Cache.Cache.Close">
            <summary> Closes the cache.</summary>
        </member>
        <member name="T:Lucene.Net.Util.Cache.Cache.SynchronizedCache_Renamed_Class">
            <summary> Simple Cache wrapper that synchronizes all
            calls that access the cache. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.Cache.SimpleMapCache.KeySet">
            <summary> Returns a Set containing all keys in this cache.</summary>
        </member>
        <member name="F:Lucene.Net.Util.Cache.SimpleLRUCache.capacity">
            <summary>
            The maximum number of items to cache.
            </summary>
        </member>
        <member name="F:Lucene.Net.Util.Cache.SimpleLRUCache.list">
            <summary>
            The list to efficiently maintain the LRU state.
            </summary>
        </member>
        <member name="F:Lucene.Net.Util.Cache.SimpleLRUCache.lookup">
            <summary>
            The dictionary to hash into any location in the list.
            </summary>
        </member>
        <member name="F:Lucene.Net.Util.Cache.SimpleLRUCache.openNode">
            <summary>
            The node instance to use/re-use when adding an item to the cache.
            </summary>
        </member>
        <member name="T:Lucene.Net.Util.Cache.SimpleLRUCache.ListValueEntry">
            <summary>
            Container to hold the key and value to aid in removal from 
            the <see cref="F:Lucene.Net.Util.Cache.SimpleLRUCache.lookup"/> dictionary when an item is removed from cache.
            </summary>
        </member>
        <member name="T:Lucene.Net.Util.ArrayUtil">
            <summary> Methods for manipulating arrays.</summary>
        </member>
        <member name="M:Lucene.Net.Util.ArrayUtil.ParseInt(System.Char[])">
            <summary> Parses the string argument as if it was an int value and returns the
            result. Throws NumberFormatException if the string does not represent an
            int quantity.
            
            </summary>
            <param name="chars">a string representation of an int quantity.
            </param>
            <returns> int the value represented by the argument
            </returns>
            <throws>  NumberFormatException if the argument could not be parsed as an int quantity. </throws>
        </member>
        <member name="M:Lucene.Net.Util.ArrayUtil.ParseInt(System.Char[],System.Int32,System.Int32)">
            <summary> Parses a char array into an int.</summary>
            <param name="chars">the character array
            </param>
            <param name="offset">The offset into the array
            </param>
            <param name="len">The length
            </param>
            <returns> the int
            </returns>
            <throws>  NumberFormatException if it can't parse </throws>
        </member>
        <member name="M:Lucene.Net.Util.ArrayUtil.ParseInt(System.Char[],System.Int32,System.Int32,System.Int32)">
            <summary> Parses the string argument as if it was an int value and returns the
            result. Throws NumberFormatException if the string does not represent an
            int quantity. The second argument specifies the radix to use when parsing
            the value.
            
            </summary>
            <param name="chars">a string representation of an int quantity.
            </param>
            <param name="radix">the base to use for conversion.
            </param>
            <returns> int the value represented by the argument
            </returns>
            <throws>  NumberFormatException if the argument could not be parsed as an int quantity. </throws>
        </member>
        <member name="M:Lucene.Net.Util.ArrayUtil.HashCode(System.Char[],System.Int32,System.Int32)">
            <summary> Returns hash of chars in range start (inclusive) to
            end (inclusive)
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.ArrayUtil.HashCode(System.Byte[],System.Int32,System.Int32)">
            <summary> Returns hash of chars in range start (inclusive) to
            end (inclusive)
            </summary>
        </member>
        <member name="T:Lucene.Net.Search.TopScoreDocCollector">
            <summary> A {@link Collector} implementation that collects the top-scoring hits,
            returning them as a {@link TopDocs}. This is used by {@link IndexSearcher} to
            implement {@link TopDocs}-based search. Hits are sorted by score descending
            and then (when the scores are tied) docID ascending. When you create an
            instance of this collector you should know in advance whether documents are
            going to be collected in doc Id order or not.
            
            <p/><b>NOTE</b>: The values {@link Float#NaN} and
            {Float#NEGATIVE_INFINITY} are not valid scores.  This
            collector will not properly collect hits with such
            scores.
            </summary>
        </member>
        <member name="T:Lucene.Net.Search.TopDocsCollector">
            <summary> A base class for all collectors that return a {@link TopDocs} output. This
            collector allows easy extension by providing a single constructor which
            accepts a {@link PriorityQueue} as well as protected members for that
            priority queue and a counter of the number of total hits.<br/>
            Extending classes can override {@link #TopDocs(int, int)} and
            {@link #GetTotalHits()} in order to provide their own implementation.
            </summary>
        </member>
        <member name="T:Lucene.Net.Search.Collector">
            <summary> <p/>Expert: Collectors are primarily meant to be used to
            gather raw results from a search, and implement sorting
            or custom result filtering, collation, etc. <p/>
            
            <p/>As of 2.9, this class replaces the deprecated
            HitCollector, and offers an API for efficient collection
            of hits across sequential {@link IndexReader}s. {@link
            IndexSearcher} advances the collector through each of the
            sub readers, in an arbitrary order. This results in a
            higher performance means of collection.<p/>
            
            <p/>Lucene's core collectors are derived from Collector.
            Likely your application can use one of these classes, or
            subclass {@link TopDocsCollector}, instead of
            implementing Collector directly:
            
            <ul>
            
            <li>{@link TopDocsCollector} is an abstract base class
            that assumes you will retrieve the top N docs,
            according to some criteria, after collection is
            done.  </li>
            
            <li>{@link TopScoreDocCollector} is a concrete subclass
            {@link TopDocsCollector} and sorts according to score +
            docID.  This is used internally by the {@link
            IndexSearcher} search methods that do not take an
            explicit {@link Sort}. It is likely the most frequently
            used collector.</li>
            
            <li>{@link TopFieldCollector} subclasses {@link
            TopDocsCollector} and sorts according to a specified
            {@link Sort} object (sort by field).  This is used
            internally by the {@link IndexSearcher} search methods
            that take an explicit {@link Sort}.</li>
            
            <li>{@link TimeLimitingCollector}, which wraps any other
            Collector and aborts the search if it's taken too much
            time, will subclass Collector in 3.0 (presently it
            subclasses the deprecated HitCollector).</li>
            
            <li>{@link PositiveScoresOnlyCollector} wraps any other
            Collector and prevents collection of hits whose score
            is &lt;= 0.0</li>
            
            </ul>
            
            <p/>Collector decouples the score from the collected doc:
            the score computation is skipped entirely if it's not
            needed.  Collectors that do need the score should
            implement the {@link #setScorer} method, to hold onto the
            passed {@link Scorer} instance, and call {@link
            Scorer#Score()} within the collect method to compute the
            current hit's score.  If your collector may request the
            score for a single hit multiple times, you should use
            {@link ScoreCachingWrappingScorer}. <p/>
            
            <p/><b>NOTE:</b> The doc that is passed to the collect
            method is relative to the current reader. If your
            collector needs to resolve this to the docID space of the
            Multi*Reader, you must re-base it by recording the
            docBase from the most recent setNextReader call.  Here's
            a simple example showing how to collect docIDs into a
            BitSet:<p/>
            
            <pre>
            Searcher searcher = new IndexSearcher(indexReader);
            final BitSet bits = new BitSet(indexReader.maxDoc());
            searcher.search(query, new Collector() {
            private int docBase;
            
            <em>// ignore scorer</em>
            public void setScorer(Scorer scorer) {
            }
            
            <em>// accept docs out of order (for a BitSet it doesn't matter)</em>
            public boolean acceptsDocsOutOfOrder() {
            return true;
            }
            
            public void collect(int doc) {
            bits.set(doc + docBase);
            }
            
            public void setNextReader(IndexReader reader, int docBase) {
            this.docBase = docBase;
            }
            });
            </pre>
            
            <p/>Not all collectors will need to rebase the docID.  For
            example, a collector that simply counts the total number
            of hits would skip it.<p/>
            
            <p/><b>NOTE:</b> Prior to 2.9, Lucene silently filtered
            out hits with score &lt;= 0.  As of 2.9, the core Collectors
            no longer do that.  It's very unusual to have such hits
            (a negative query boost, or function query returning
            negative custom scores, could cause it to happen).  If
            you need that behavior, use {@link
            PositiveScoresOnlyCollector}.<p/>
            
            <p/><b>NOTE:</b> This API is experimental and might change
            in incompatible ways in the next release.<p/>
            
            </summary>
            <since> 2.9
            </since>
        </member>
        <member name="M:Lucene.Net.Search.Collector.SetScorer(Lucene.Net.Search.Scorer)">
            <summary> Called before successive calls to {@link #Collect(int)}. Implementations
            that need the score of the current document (passed-in to
            {@link #Collect(int)}), should save the passed-in Scorer and call
            scorer.score() when needed.
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.Collector.Collect(System.Int32)">
            <summary> Called once for every document matching a query, with the unbased document
            number.
            
            <p/>
            Note: This is called in an inner search loop. For good search performance,
            implementations of this method should not call {@link Searcher#Doc(int)} or
            {@link Lucene.Net.Index.IndexReader#Document(int)} on every hit.
            Doing so can slow searches by an order of magnitude or more.
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.Collector.SetNextReader(Lucene.Net.Index.IndexReader,System.Int32)">
            <summary> Called before collecting from each IndexReader. All doc ids in
            {@link #Collect(int)} will correspond to reader.
            
            Add docBase to the current IndexReaders internal document id to re-base ids
            in {@link #Collect(int)}.
            
            </summary>
            <param name="reader">next IndexReader
            </param>
            <param name="docBase">
            </param>
        </member>
        <member name="M:Lucene.Net.Search.Collector.AcceptsDocsOutOfOrder">
            <summary>
             * Return <code>true</code> if this collector does not
             * require the matching docIDs to be delivered in int sort
             * order (smallest to largest) to {@link #collect}.
             *
             * <p/> Most Lucene Query implementations will visit
             * matching docIDs in order.  However, some queries
             * (currently limited to certain cases of {@link
             * BooleanQuery}) can achieve faster searching if the
             * <code>Collector</code> allows them to deliver the
             * docIDs out of order.
             *
             * <p/> Many collectors don't mind getting docIDs out of
             * order, so it's important to return <code>true</code>
             * here.
             *
            </summary>
            <returns></returns>
        </member>
        <member name="F:Lucene.Net.Search.TopDocsCollector.pq">
            <summary> The priority queue which holds the top documents. Note that different
            implementations of PriorityQueue give different meaning to 'top documents'.
            HitQueue for example aggregates the top scoring documents, while other PQ
            implementations may hold documents sorted by other criteria.
            </summary>
        </member>
        <member name="F:Lucene.Net.Search.TopDocsCollector.totalHits">
            <summary>The total number of documents that the collector encountered. </summary>
        </member>
        <member name="M:Lucene.Net.Search.TopDocsCollector.PopulateResults(Lucene.Net.Search.ScoreDoc[],System.Int32)">
            <summary> Populates the results array with the ScoreDoc instaces. This can be
            overridden in case a different ScoreDoc type should be returned.
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.TopDocsCollector.NewTopDocs(Lucene.Net.Search.ScoreDoc[],System.Int32)">
            <summary> Returns a {@link TopDocs} instance containing the given results. If
            <code>results</code> is null it means there are no results to return,
            either because there were 0 calls to collect() or because the arguments to
            topDocs were invalid.
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.TopDocsCollector.GetTotalHits">
            <summary>The total number of documents that matched this query. </summary>
        </member>
        <member name="M:Lucene.Net.Search.TopDocsCollector.TopDocs">
            <summary>Returns the top docs that were collected by this collector. </summary>
        </member>
        <member name="M:Lucene.Net.Search.TopDocsCollector.TopDocs(System.Int32)">
            <summary> Returns the documents in the rage [start .. pq.size()) that were collected
            by this collector. Note that if start >= pq.size(), an empty TopDocs is
            returned.<br/>
            This method is convenient to call if the application allways asks for the
            last results, starting from the last 'page'.<br/>
            <b>NOTE:</b> you cannot call this method more than once for each search
            execution. If you need to call it more than once, passing each time a
            different <code>start</code>, you should call {@link #TopDocs()} and work
            with the returned {@link TopDocs} object, which will contain all the
            results this search execution collected.
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.TopDocsCollector.TopDocs(System.Int32,System.Int32)">
            <summary> Returns the documents in the rage [start .. start+howMany) that were
            collected by this collector. Note that if start >= pq.size(), an empty
            TopDocs is returned, and if pq.size() - start &lt; howMany, then only the
            available documents in [start .. pq.size()) are returned.<br/>
            This method is useful to call in case pagination of search results is
            allowed by the search application, as well as it attempts to optimize the
            memory used by allocating only as much as requested by howMany.<br/>
            <b>NOTE:</b> you cannot call this method more than once for each search
            execution. If you need to call it more than once, passing each time a
            different range, you should call {@link #TopDocs()} and work with the
            returned {@link TopDocs} object, which will contain all the results this
            search execution collected.
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.TopScoreDocCollector.create(System.Int32,System.Boolean)">
            <summary> Creates a new {@link TopScoreDocCollector} given the number of hits to
            collect and whether documents are scored in order by the input
            {@link Scorer} to {@link #SetScorer(Scorer)}.
            
            <p/><b>NOTE</b>: The instances returned by this method
            pre-allocate a full array of length
            <code>numHits</code>, and fill the array with sentinel
            objects.
            </summary>
        </member>
        <member name="T:Lucene.Net.Search.Spans.SpanScorer">
            <summary> Public for extension only.</summary>
        </member>
        <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="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="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.DocIdSetIterator.Doc">
            <summary> Unsupported anymore. Call {@link #DocID()} instead. This method throws
            {@link UnsupportedOperationException} if called.
            
            </summary>
            <deprecated> use {@link #DocID()} instead.
            </deprecated>
        </member>
        <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.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>
        <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.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.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>
        <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>
        <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.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.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.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>
        <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>
        <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.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="F:Lucene.Net.Search.Spans.SpanScorer.firstTime">
            <deprecated> not needed anymore 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.Spans.SpanScorer.Next">
            <deprecated> use {@link #NextDoc()} instead. 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.Spans.SpanScorer.SkipTo(System.Int32)">
            <deprecated> use {@link #Advance(int)} instead. 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.Spans.SpanScorer.Doc">
            <deprecated> use {@link #DocID()} instead. 
            </deprecated>
        </member>
        <member name="T:Lucene.Net.Search.Spans.Spans">
            <summary>Expert: an enumeration of span matches.  Used to implement span searching.
            Each span represents a range of term positions within a document.  Matches
            are enumerated in order, by increasing document number, within that by
            increasing start position and finally by increasing end position. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.Spans.Spans.Next">
            <summary>Move to the next match, returning true iff any such exists. </summary>
        </member>
        <member name="M:Lucene.Net.Search.Spans.Spans.SkipTo(System.Int32)">
            <summary>Skips to the first match beyond the current, whose document number is
            greater than or equal to <i>target</i>. <p/>Returns true iff there is such
            a match.  <p/>Behaves as if written: <pre>
            boolean skipTo(int target) {
            do {
            if (!next())
            return false;
            } while (target > doc());
            return true;
            }
            </pre>
            Most implementations are considerably more efficient than that.
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.Spans.Spans.Doc">
            <summary>Returns the document number of the current match.  Initially invalid. </summary>
        </member>
        <member name="M:Lucene.Net.Search.Spans.Spans.Start">
            <summary>Returns the start position of the current match.  Initially invalid. </summary>
        </member>
        <member name="M:Lucene.Net.Search.Spans.Spans.End">
            <summary>Returns the end position of the current match.  Initially invalid. </summary>
        </member>
        <member name="M:Lucene.Net.Search.Spans.Spans.GetPayload">
            <summary> Returns the payload data for the current span.
            This is invalid until {@link #Next()} is called for
            the first time.
            This method must not be called more than once after each call
            of {@link #Next()}. However, most payloads are loaded lazily,
            so if the payload data for the current position is not needed,
            this method may not be called at all for performance reasons. An ordered
            SpanQuery does not lazy load, so if you have payloads in your index and
            you do not want ordered SpanNearQuerys to collect payloads, you can
            disable collection with a constructor option.<br/>
            
            Note that the return type is a collection, thus the ordering should not be relied upon.
            <br/>
            <p/><font color="#FF0000">
            WARNING: The status of the <b>Payloads</b> feature is experimental.
            The APIs introduced here might change in the future and will not be
            supported anymore in such a case.</font><p/>
            
            </summary>
            <returns> a List of byte arrays containing the data of this payload, otherwise null if isPayloadAvailable is false
            </returns>
            <throws>  java.io.IOException </throws>
        </member>
        <member name="M:Lucene.Net.Search.Spans.Spans.IsPayloadAvailable">
            <summary> Checks if a payload can be loaded at this position.
            <p/>
            Payloads can only be loaded once per call to
            {@link #Next()}.
            
            </summary>
            <returns> true if there is a payload available at this position that can be loaded
            </returns>
        </member>
        <member name="T:Lucene.Net.Search.Spans.SpanNotQuery">
            <summary>Removes matches which overlap with another SpanQuery. </summary>
        </member>
        <member name="T:Lucene.Net.Search.Spans.SpanQuery">
            <summary>Base class for span-based queries. </summary>
        </member>
        <member name="T:Lucene.Net.Search.Query">
            <summary>The abstract base class for queries.
            <p/>Instantiable subclasses are:
            <ul>
            <li> {@link TermQuery} </li>
            <li> {@link MultiTermQuery} </li>
            <li> {@link BooleanQuery} </li>
            <li> {@link WildcardQuery} </li>
            <li> {@link PhraseQuery} </li>
            <li> {@link PrefixQuery} </li>
            <li> {@link MultiPhraseQuery} </li>
            <li> {@link FuzzyQuery} </li>
            <li> {@link TermRangeQuery} </li>
            <li> {@link NumericRangeQuery} </li>
            <li> {@link Lucene.Net.Search.Spans.SpanQuery} </li>
            </ul>
            <p/>A parser for queries is contained in:
            <ul>
            <li>{@link Lucene.Net.QueryParsers.QueryParser QueryParser} </li>
            </ul>
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.Query.SetBoost(System.Single)">
            <summary>Sets the boost for this query clause to <code>b</code>.  Documents
            matching this clause will (in addition to the normal weightings) have
            their score multiplied by <code>b</code>.
            </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.
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.Query.ToString(System.String)">
            <summary>Prints a query to a string, with <code>field</code> assumed to be the 
            default field and omitted.
            <p/>The representation used is one that is supposed to be readable
            by {@link Lucene.Net.QueryParsers.QueryParser QueryParser}. However,
            there are the following limitations:
            <ul>
            <li>If the query was created by the parser, the printed
            representation may not be exactly what was parsed. For example,
            characters that need to be escaped will be represented without
            the required backslash.</li>
            <li>Some of the more complicated queries (e.g. span queries)
            don't have a representation that can be parsed by QueryParser.</li>
            </ul>
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.Query.ToString">
            <summary>Prints a query to a string. </summary>
        </member>
        <member name="M:Lucene.Net.Search.Query.CreateWeight(Lucene.Net.Search.Searcher)">
            <summary> Expert: Constructs an appropriate Weight implementation for this query.
            
            <p/>
            Only implemented by primitive queries, which re-write to themselves.
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.Query.Weight(Lucene.Net.Search.Searcher)">
            <summary> Expert: Constructs and initializes a Weight for a top-level query.</summary>
        </member>
        <member name="M:Lucene.Net.Search.Query.Rewrite(Lucene.Net.Index.IndexReader)">
            <summary>Expert: called to re-write queries into primitive queries. For example,
            a PrefixQuery will be rewritten into a BooleanQuery that consists
            of TermQuerys.
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.Query.Combine(Lucene.Net.Search.Query[])">
            <summary>Expert: called when re-writing queries under MultiSearcher.
            
            Create a single query suitable for use by all subsearchers (in 1-1
            correspondence with queries). This is an optimization of the OR of
            all queries. We handle the common optimization cases of equal
            queries and overlapping clauses of boolean OR queries (as generated
            by MultiTermQuery.rewrite()).
            Be careful overriding this method as queries[0] determines which
            method will be called and is not necessarily of the same type as
            the other queries.
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.Query.ExtractTerms(System.Collections.Hashtable)">
            <summary> Expert: adds all terms occuring in this query to the terms set. Only
            works if this query is in its {@link #rewrite rewritten} form.
            
            </summary>
            <throws>  UnsupportedOperationException if this query is not yet rewritten </throws>
        </member>
        <member name="M:Lucene.Net.Search.Query.MergeBooleanQueries(Lucene.Net.Search.BooleanQuery[])">
            <summary>Expert: merges the clauses of a set of BooleanQuery's into a single
            BooleanQuery.
            
            <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
            implementation, perhaps one that delegates through that of the Searcher.
            By default the Searcher's Similarity implementation is returned.
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.Query.Clone">
            <summary>Returns a clone of this query. </summary>
        </member>
        <member name="M:Lucene.Net.Search.Spans.SpanQuery.GetSpans(Lucene.Net.Index.IndexReader)">
            <summary>Expert: Returns the matches for this query in an index.  Used internally
            to search for spans. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.Spans.SpanQuery.GetField">
            <summary>Returns the name of the field matched by this query.</summary>
        </member>
        <member name="M:Lucene.Net.Search.Spans.SpanQuery.GetTerms">
            <summary>Returns a collection of all terms matched by this query.</summary>
            <deprecated> use extractTerms instead
            </deprecated>
            <seealso cref="!:Query.ExtractTerms(Set)">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Search.Spans.SpanNotQuery.#ctor(Lucene.Net.Search.Spans.SpanQuery,Lucene.Net.Search.Spans.SpanQuery)">
            <summary>Construct a SpanNotQuery matching spans from <code>include</code> which
            have no overlap with spans from <code>exclude</code>.
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.Spans.SpanNotQuery.GetInclude">
            <summary>Return the SpanQuery whose matches are filtered. </summary>
        </member>
        <member name="M:Lucene.Net.Search.Spans.SpanNotQuery.GetExclude">
            <summary>Return the SpanQuery whose matches must not overlap those returned. </summary>
        </member>
        <member name="M:Lucene.Net.Search.Spans.SpanNotQuery.GetTerms">
            <summary>Returns a collection of all terms matched by this query.</summary>
            <deprecated> use extractTerms instead
            </deprecated>
            <seealso cref="!:ExtractTerms(Set)">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Search.Spans.SpanNotQuery.Equals(System.Object)">
            <summary>Returns true iff <code>o</code> is equal to this. </summary>
        </member>
        <member name="T:Lucene.Net.Search.PrefixFilter">
            <summary> A Filter that restricts search results to values that have a matching prefix in a given
            field.
            </summary>
        </member>
        <member name="T:Lucene.Net.Search.MultiTermQueryWrapperFilter">
            <summary> A wrapper for {@link MultiTermQuery}, that exposes its
            functionality as a {@link Filter}.
            <p/>
            <code>MultiTermQueryWrapperFilter</code> is not designed to
            be used by itself. Normally you subclass it to provide a Filter
            counterpart for a {@link MultiTermQuery} subclass.
            <p/>
            For example, {@link TermRangeFilter} and {@link PrefixFilter} extend
            <code>MultiTermQueryWrapperFilter</code>.
            This class also provides the functionality behind
            {@link MultiTermQuery#CONSTANT_SCORE_FILTER_REWRITE};
            this is why it is not abstract.
            </summary>
        </member>
        <member name="T:Lucene.Net.Search.Filter">
            <summary>Abstract base class for restricting which documents may be returned during searching.
            <p/>
            <b>Note:</b> In Lucene 3.0 {@link #Bits(IndexReader)} will be removed
            and {@link #GetDocIdSet(IndexReader)} will be defined as abstract.
            All implementing classes must therefore implement {@link #GetDocIdSet(IndexReader)}
            in order to work with Lucene 3.0.
            </summary>
        </member>
        <!-- Badly formed XML comment ignored for member "M:Lucene.Net.Search.Filter.Bits(Lucene.Net.Index.IndexReader)" -->
        <member name="M:Lucene.Net.Search.Filter.GetDocIdSet(Lucene.Net.Index.IndexReader)">
            <summary>
              Creates a {@link DocIdSet} enumerating the documents that should be
              permitted in search results. <b>NOTE:</b> null can be
              returned if no documents are accepted by this Filter.
              <p/>
              Note: This method will be called once per segment in
              the index during searching.  The returned {@link DocIdSet}
              must refer to document IDs for that segment, not for
              the top-level reader.
               
              @param reader a {@link IndexReader} instance opened on the index currently
                       searched on. Note, it is likely that the provided reader does not
                       represent the whole underlying index i.e. if the index has more than
                       one segment the given reader only represents a single segment.
                        
            </summary>
             <returns> a DocIdSet that provides the documents which should be permitted or
             prohibited in search results. <b>NOTE:</b> null can be returned if
             no documents will be accepted by this Filter.
             </returns>
             <seealso cref="T:Lucene.Net.Util.DocIdBitSet">
             </seealso>
        </member>
        <member name="M:Lucene.Net.Search.MultiTermQueryWrapperFilter.#ctor(Lucene.Net.Search.MultiTermQuery)">
            <summary> Wrap a {@link MultiTermQuery} as a Filter.</summary>
        </member>
        <member name="M:Lucene.Net.Search.MultiTermQueryWrapperFilter.GetTotalNumberOfTerms">
            <summary> Expert: Return the number of unique terms visited during execution of the filter.
            If there are many of them, you may consider using another filter type
            or optimize your total term count in index.
            <p/>This method is not thread safe, be sure to only call it when no filter is running!
            If you re-use the same filter instance for another
            search, be sure to first reset the term counter
            with {@link #clearTotalNumberOfTerms}.
            </summary>
            <seealso cref="!:clearTotalNumberOfTerms">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Search.MultiTermQueryWrapperFilter.ClearTotalNumberOfTerms">
            <summary> Expert: Resets the counting of unique terms.
            Do this before executing the filter.
            </summary>
            <seealso cref="!:getTotalNumberOfTerms">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Search.MultiTermQueryWrapperFilter.Bits(Lucene.Net.Index.IndexReader)">
            <summary> Returns a BitSet with true for documents which should be
            permitted in search results, and false for those that should
            not.
            </summary>
            <deprecated> Use {@link #GetDocIdSet(IndexReader)} instead.
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.MultiTermQueryWrapperFilter.GetDocIdSet(Lucene.Net.Index.IndexReader)">
            <summary> Returns a DocIdSet with documents that should be
            permitted in search results.
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.PrefixFilter.ToString">
            <summary>Prints a user-readable version of this query. </summary>
        </member>
        <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.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.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.Util.PriorityQueue.Initialize(System.Int32)">
            <summary>Subclass constructors must call this. </summary>
        </member>
        <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>
            <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.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.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.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.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.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="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="M:Lucene.Net.Util.PriorityQueue.Size">
            <summary>Returns the number of elements currently stored in the PriorityQueue. </summary>
        </member>
        <member name="M:Lucene.Net.Util.PriorityQueue.Clear">
            <summary>Removes all entries from the PriorityQueue. </summary>
        </member>
        <member name="M:Lucene.Net.Search.HitQueue.#ctor(System.Int32,System.Boolean)">
            <summary> Creates a new instance with <code>size</code> elements. If
            <code>prePopulate</code> is set to true, the queue will pre-populate itself
            with sentinel objects and set its {@link #Size()} to <code>size</code>. In
            that case, you should not rely on {@link #Size()} to get the number of
            actual elements that were added to the queue, but keep track yourself.<br/>
            <b>NOTE:</b> in case <code>prePopulate</code> is true, you should pop
            elements from the queue using the following code example:
            
            <pre>
            PriorityQueue pq = new HitQueue(10, true); // pre-populate.
            ScoreDoc top = pq.top();
            
            // Add/Update one element.
            top.score = 1.0f;
            top.doc = 0;
            top = (ScoreDoc) pq.updateTop();
            int totalHits = 1;
            
            // Now pop only the elements that were *truly* inserted.
            // First, pop all the sentinel elements (there are pq.size() - totalHits).
            for (int i = pq.size() - totalHits; i &gt; 0; i--) pq.pop();
            
            // Now pop the truly added elements.
            ScoreDoc[] results = new ScoreDoc[totalHits];
            for (int i = totalHits - 1; i &gt;= 0; i--) {
            results[i] = (ScoreDoc) pq.pop();
            }
            </pre>
            
            <p/><b>NOTE</b>: This class pre-allocate a full array of
            length <code>size</code>.
            
            </summary>
            <param name="size">the requested size of this queue.
            </param>
            <param name="prePopulate">specifies whether to pre-populate the queue with sentinel values.
            </param>
            <seealso cref="M:Lucene.Net.Search.HitQueue.GetSentinelObject">
            </seealso>
        </member>
        <member name="T:Lucene.Net.Search.FuzzyTermEnum">
            <summary>Subclass of FilteredTermEnum for enumerating all terms that are similiar
            to the specified filter term.
            
            <p/>Term enumerations are always ordered by Term.compareTo().  Each term in
            the enumeration is greater than all that precede it.
            </summary>
        </member>
        <member name="T:Lucene.Net.Search.FilteredTermEnum">
            <summary>Abstract class for enumerating a subset of all terms. 
            <p/>Term enumerations are always ordered by Term.compareTo().  Each term in
            the enumeration is greater than all that precede it.  
            </summary>
        </member>
        <member name="T:Lucene.Net.Index.TermEnum">
            <summary>Abstract class for enumerating terms.
            <p/>Term enumerations are always ordered by Term.compareTo().  Each term in
            the enumeration is greater than all that precede it.  
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.TermEnum.Next">
            <summary>Increments the enumeration to the next element.  True if one exists.</summary>
        </member>
        <member name="M:Lucene.Net.Index.TermEnum.Term">
            <summary>Returns the current Term in the enumeration.</summary>
        </member>
        <member name="M:Lucene.Net.Index.TermEnum.DocFreq">
            <summary>Returns the docFreq of the current Term in the enumeration.</summary>
        </member>
        <member name="M:Lucene.Net.Index.TermEnum.Close">
            <summary>Closes the enumeration to further activity, freeing resources. </summary>
        </member>
        <member name="M:Lucene.Net.Index.TermEnum.SkipTo(Lucene.Net.Index.Term)">
            <summary>Skips terms to the first beyond the current whose value is
            greater or equal to <i>target</i>. <p/>Returns true iff there is such
            an entry.  <p/>Behaves as if written: <pre>
            public boolean skipTo(Term target) {
            do {
            if (!next())
            return false;
            } while (target > term());
            return true;
            }
            </pre>
            Some implementations *could* be considerably more efficient than a linear scan.
            Check the implementation to be sure.
            </summary>
            <deprecated> This method is not performant and will be removed in Lucene 3.0.
            Use {@link IndexReader#Terms(Term)} to create a new TermEnum positioned at a
            given term.
            </deprecated>
        </member>
        <member name="F:Lucene.Net.Search.FilteredTermEnum.currentTerm">
            <summary>the current term </summary>
        </member>
        <member name="F:Lucene.Net.Search.FilteredTermEnum.actualEnum">
            <summary>the delegate enum - to set this member use {@link #setEnum} </summary>
        </member>
        <member name="M:Lucene.Net.Search.FilteredTermEnum.TermCompare(Lucene.Net.Index.Term)">
            <summary>Equality compare on the term </summary>
        </member>
        <member name="M:Lucene.Net.Search.FilteredTermEnum.Difference">
            <summary>Equality measure on the term </summary>
        </member>
        <member name="M:Lucene.Net.Search.FilteredTermEnum.EndEnum">
            <summary>Indicates the end of the enumeration has been reached </summary>
        </member>
        <member name="M:Lucene.Net.Search.FilteredTermEnum.SetEnum(Lucene.Net.Index.TermEnum)">
            <summary> use this method to set the actual TermEnum (e.g. in ctor),
            it will be automatically positioned on the first matching term.
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.FilteredTermEnum.DocFreq">
            <summary> Returns the docFreq of the current Term in the enumeration.
            Returns -1 if no Term matches or all terms have been enumerated.
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.FilteredTermEnum.Next">
            <summary>Increments the enumeration to the next element.  True if one exists. </summary>
        </member>
        <member name="M:Lucene.Net.Search.FilteredTermEnum.Term">
            <summary>Returns the current Term in the enumeration.
            Returns null if no Term matches or all terms have been enumerated. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.FilteredTermEnum.Close">
            <summary>Closes the enumeration to further activity, freeing resources.  </summary>
        </member>
        <member name="M:Lucene.Net.Search.FuzzyTermEnum.#ctor(Lucene.Net.Index.IndexReader,Lucene.Net.Index.Term)">
            <summary> Creates a FuzzyTermEnum with an empty prefix and a minSimilarity of 0.5f.
            <p/>
            After calling the constructor the enumeration is already pointing to the first 
            valid term if such a term exists. 
            
            </summary>
            <param name="reader">
            </param>
            <param name="term">
            </param>
            <throws>  IOException </throws>
            <seealso cref="M:Lucene.Net.Search.FuzzyTermEnum.#ctor(Lucene.Net.Index.IndexReader,Lucene.Net.Index.Term,System.Single,System.Int32)">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Search.FuzzyTermEnum.#ctor(Lucene.Net.Index.IndexReader,Lucene.Net.Index.Term,System.Single)">
            <summary> Creates a FuzzyTermEnum with an empty prefix.
            <p/>
            After calling the constructor the enumeration is already pointing to the first 
            valid term if such a term exists. 
            
            </summary>
            <param name="reader">
            </param>
            <param name="term">
            </param>
            <param name="minSimilarity">
            </param>
            <throws>  IOException </throws>
            <seealso cref="M:Lucene.Net.Search.FuzzyTermEnum.#ctor(Lucene.Net.Index.IndexReader,Lucene.Net.Index.Term,System.Single,System.Int32)">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Search.FuzzyTermEnum.#ctor(Lucene.Net.Index.IndexReader,Lucene.Net.Index.Term,System.Single,System.Int32)">
            <summary> Constructor for enumeration of all terms from specified <code>reader</code> which share a prefix of
            length <code>prefixLength</code> with <code>term</code> and which have a fuzzy similarity &gt;
            <code>minSimilarity</code>.
            <p/>
            After calling the constructor the enumeration is already pointing to the first 
            valid term if such a term exists. 
            
            </summary>
            <param name="reader">Delivers terms.
            </param>
            <param name="term">Pattern term.
            </param>
            <param name="minSimilarity">Minimum required similarity for terms from the reader. Default value is 0.5f.
            </param>
            <param name="prefixLength">Length of required common prefix. Default value is 0.
            </param>
            <throws>  IOException </throws>
        </member>
        <member name="M:Lucene.Net.Search.FuzzyTermEnum.TermCompare(Lucene.Net.Index.Term)">
            <summary> The termCompare method in FuzzyTermEnum uses Levenshtein distance to 
            calculate the distance between the given term and the comparing term. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.FuzzyTermEnum.Min(System.Int32,System.Int32,System.Int32)">
            <summary> Finds and returns the smallest of three integers </summary>
        </member>
        <member name="M:Lucene.Net.Search.FuzzyTermEnum.Similarity(System.String)">
            <summary> <p/>Similarity returns a number that is 1.0f or less (including negative numbers)
            based on how similar the Term is compared to a target term.  It returns
            exactly 0.0f when
            <pre>
            editDistance &lt; maximumEditDistance</pre>
            Otherwise it returns:
            <pre>
            1 - (editDistance / length)</pre>
            where length is the length of the shortest term (text or target) including a
            prefix that are identical and editDistance is the Levenshtein distance for
            the two words.<p/>
            
            <p/>Embedded within this algorithm is a fail-fast Levenshtein distance
            algorithm.  The fail-fast algorithm differs from the standard Levenshtein
            distance algorithm in that it is aborted if it is discovered that the
            mimimum distance between the words is greater than some threshold.
            
            <p/>To calculate the maximum distance threshold we use the following formula:
            <pre>
            (1 - minimumSimilarity) * length</pre>
            where length is the shortest term including any prefix that is not part of the
            similarity comparision.  This formula was derived by solving for what maximum value
            of distance returns false for the following statements:
            <pre>
            similarity = 1 - ((float)distance / (float) (prefixLength + Math.min(textlen, targetlen)));
            return (similarity > minimumSimilarity);</pre>
            where distance is the Levenshtein distance for the two words.
            <p/>
            <p/>Levenshtein distance (also known as edit distance) is a measure of similiarity
            between two strings where the distance is measured as the number of character
            deletions, insertions or substitutions required to transform one string to
            the other string.
            </summary>
            <param name="target">the target word or phrase
            </param>
            <returns> the similarity,  0.0 or less indicates that it matches less than the required
            threshold and 1.0 indicates that the text and target are identical
            </returns>
        </member>
        <member name="M:Lucene.Net.Search.FuzzyTermEnum.GrowDistanceArray(System.Int32)">
            <summary> Grow the second dimension of the array, so that we can calculate the
            Levenshtein difference.
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.FuzzyTermEnum.GetMaxDistance(System.Int32)">
            <summary> The max Distance is the maximum Levenshtein distance for the text
            compared to some other value that results in score that is
            better than the minimum similarity.
            </summary>
            <param name="m">the length of the "other value"
            </param>
            <returns> the maximum levenshtein distance that we care about
            </returns>
        </member>
        <member name="T:Lucene.Net.Search.Function.FloatFieldSource">
            <summary> Expert: obtains float field values from the 
            {@link Lucene.Net.Search.FieldCache FieldCache}
            using <code>getFloats()</code> and makes those values 
            available as other numeric types, casting as needed.
            
            <p/><font color="#FF0000">
            WARNING: The status of the <b>Search.Function</b> package is experimental. 
            The APIs introduced here might change in the future and will not be 
            supported anymore in such a case.</font>
            
            </summary>
            <seealso cref="T:Lucene.Net.Search.Function.FieldCacheSource"> for requirements"
            on the field.
            
            <p/><b>NOTE</b>: with the switch in 2.9 to segment-based
            searching, if {@link #getValues} is invoked with a
            composite (multi-segment) reader, this can easily cause
            double RAM usage for the values in the FieldCache.  It's
            best to switch your application to pass only atomic
            (single segment) readers to this API.  Alternatively, for
            a short-term fix, you could wrap your ValueSource using
            {@link MultiValueSource}, which costs more CPU per lookup
            but will not consume double the FieldCache RAM.<p/>
            </seealso>
        </member>
        <member name="T:Lucene.Net.Search.Function.FieldCacheSource">
            <summary> Expert: A base class for ValueSource implementations that retrieve values for
            a single field from the {@link Lucene.Net.Search.FieldCache FieldCache}.
            <p/>
            Fields used herein nust be indexed (doesn't matter if these fields are stored or not).
            <p/> 
            It is assumed that each such indexed field is untokenized, or at least has a single token in a document.
            For documents with multiple tokens of the same field, behavior is undefined (It is likely that current 
            code would use the value of one of these tokens, but this is not guaranteed).
            <p/>
            Document with no tokens in this field are assigned the <code>Zero</code> value.    
            
            <p/><font color="#FF0000">
            WARNING: The status of the <b>Search.Function</b> package is experimental. 
            The APIs introduced here might change in the future and will not be 
            supported anymore in such a case.</font>
            
            <p/><b>NOTE</b>: with the switch in 2.9 to segment-based
            searching, if {@link #getValues} is invoked with a
            composite (multi-segment) reader, this can easily cause
            double RAM usage for the values in the FieldCache.  It's
            best to switch your application to pass only atomic
            (single segment) readers to this API.  Alternatively, for
            a short-term fix, you could wrap your ValueSource using
            {@link MultiValueSource}, which costs more CPU per lookup
            but will not consume double the FieldCache RAM.<p/>
            </summary>
        </member>
        <member name="T:Lucene.Net.Search.Function.ValueSource">
            <summary> Expert: source of values for basic function queries.
            <p/>At its default/simplest form, values - one per doc - are used as the score of that doc.
            <p/>Values are instantiated as 
            {@link Lucene.Net.Search.Function.DocValues DocValues} for a particular reader.
            <p/>ValueSource implementations differ in RAM requirements: it would always be a factor
            of the number of documents, but for each document the number of bytes can be 1, 2, 4, or 8. 
            
            <p/><font color="#FF0000">
            WARNING: The status of the <b>Search.Function</b> package is experimental. 
            The APIs introduced here might change in the future and will not be 
            supported anymore in such a case.</font>
            
            
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.Function.ValueSource.GetValues(Lucene.Net.Index.IndexReader)">
            <summary> Return the DocValues used by the function query.</summary>
            <param name="reader">the IndexReader used to read these values.
            If any caching is involved, that caching would also be IndexReader based.  
            </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.FieldCacheSource.#ctor(System.String)">
            <summary> Create a cached field source for the input field.  </summary>
        </member>
        <member name="M:Lucene.Net.Search.Function.FieldCacheSource.GetCachedFieldValues(Lucene.Net.Search.FieldCache,System.String,Lucene.Net.Index.IndexReader)">
            <summary> Return cached DocValues for input field and reader.</summary>
            <param name="cache">FieldCache so that values of a field are loaded once per reader (RAM allowing)
            </param>
            <param name="field">Field for which values are required.
            </param>
            <seealso cref="T:Lucene.Net.Search.Function.ValueSource">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Search.Function.FieldCacheSource.CachedFieldSourceEquals(Lucene.Net.Search.Function.FieldCacheSource)">
            <summary> Check if equals to another {@link FieldCacheSource}, already knowing that cache and field are equal.  </summary>
            <seealso cref="!:Object.equals(java.lang.Object)">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Search.Function.FieldCacheSource.CachedFieldSourceHashCode">
            <summary> Return a hash code of a {@link FieldCacheSource}, without the hash-codes of the field 
            and the cache (those are taken care of elsewhere).  
            </summary>
            <seealso cref="!:Object.hashCode()">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Search.Function.FloatFieldSource.#ctor(System.String)">
            <summary> Create a cached float field source with default string-to-float parser. </summary>
        </member>
        <member name="M:Lucene.Net.Search.Function.FloatFieldSource.#ctor(System.String,Lucene.Net.Search.FloatParser)">
            <summary> Create a cached float field source with a specific string-to-float parser. </summary>
        </member>
        <member name="T:Lucene.Net.Search.Function.DocValues">
            <summary> Expert: represents field values as different types.
            Normally created via a 
            {@link Lucene.Net.Search.Function.ValueSource ValueSuorce} 
            for a particular field and reader.
            
            <p/><font color="#FF0000">
            WARNING: The status of the <b>Search.Function</b> package is experimental. 
            The APIs introduced here might change in the future and will not be 
            supported anymore in such a case.</font>
            
            
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.Function.DocValues.FloatVal(System.Int32)">
            <summary> Return doc value as a float. 
            <p/>Mandatory: every DocValues implementation must implement at least this method. 
            </summary>
            <param name="doc">document whose float value is requested. 
            </param>
        </member>
        <member name="M:Lucene.Net.Search.Function.DocValues.IntVal(System.Int32)">
            <summary> Return doc value as an int. 
            <p/>Optional: DocValues implementation can (but don't have to) override this method. 
            </summary>
            <param name="doc">document whose int value is requested.
            </param>
        </member>
        <member name="M:Lucene.Net.Search.Function.DocValues.LongVal(System.Int32)">
            <summary> Return doc value as a long. 
            <p/>Optional: DocValues implementation can (but don't have to) override this method. 
            </summary>
            <param name="doc">document whose long value is requested.
            </param>
        </member>
        <member name="M:Lucene.Net.Search.Function.DocValues.DoubleVal(System.Int32)">
            <summary> Return doc value as a double. 
            <p/>Optional: DocValues implementation can (but don't have to) override this method. 
            </summary>
            <param name="doc">document whose double value is requested.
            </param>
        </member>
        <member name="M:Lucene.Net.Search.Function.DocValues.StrVal(System.Int32)">
            <summary> Return doc value as a string. 
            <p/>Optional: DocValues implementation can (but don't have to) override this method. 
            </summary>
            <param name="doc">document whose string value is requested.
            </param>
        </member>
        <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>
        <member name="M:Lucene.Net.Search.Function.DocValues.GetInnerArray">
            <summary> Expert: for test purposes only, return the inner array of values, or null if not applicable.
            <p/>
            Allows tests to verify that loaded values are:
            <ol>
            <li>indeed cached/reused.</li>
            <li>stored in the expected size/type (byte/short/int/float).</li>
            </ol>
            Note: implementations of DocValues must override this method for 
            these test elements to be tested, Otherwise the test would not fail, just 
            print a warning.
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.Function.DocValues.GetMinValue">
            <summary> Returns the minimum of all values or <code>Float.NaN</code> if this
            DocValues instance does not contain any value.
            <p/>
            This operation is optional
            <p/>
            
            </summary>
            <returns> the minimum of all values or <code>Float.NaN</code> if this
            DocValues instance does not contain any value.
            </returns>
        </member>
        <member name="M:Lucene.Net.Search.Function.DocValues.GetMaxValue">
            <summary> Returns the maximum of all values or <code>Float.NaN</code> if this
            DocValues instance does not contain any value.
            <p/>
            This operation is optional
            <p/>
            
            </summary>
            <returns> the maximum of all values or <code>Float.NaN</code> if this
            DocValues instance does not contain any value.
            </returns>
        </member>
        <member name="M:Lucene.Net.Search.Function.DocValues.GetAverageValue">
            <summary> Returns the average of all values or <code>Float.NaN</code> if this
            DocValues instance does not contain any value. *
            <p/>
            This operation is optional
            <p/>
            
            </summary>
            <returns> the average of all values or <code>Float.NaN</code> if this
            DocValues instance does not contain any value
            </returns>
        </member>
        <member name="T:Lucene.Net.Index.TermPositions">
            <summary> TermPositions provides an interface for enumerating the &lt;document,
            frequency, &lt;position&gt;* &gt; tuples for a term.  <p/> The document and
            frequency are the same as for a TermDocs.  The positions portion lists the ordinal
            positions of each occurrence of a term in a document.
            
            </summary>
            <seealso cref="M:Lucene.Net.Index.IndexReader.TermPositions">
            </seealso>
        </member>
        <member name="T:Lucene.Net.Index.TermDocs">
            <summary>TermDocs provides an interface for enumerating &lt;document, frequency&gt;
            pairs for a term.  <p/> The document portion names each document containing
            the term.  Documents are indicated by number.  The frequency portion gives
            the number of times the term occurred in each document.  <p/> The pairs are
            ordered by document number.
            </summary>
            <seealso cref="M:Lucene.Net.Index.IndexReader.TermDocs">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Index.TermDocs.Seek(Lucene.Net.Index.Term)">
            <summary>Sets this to the data for a term.
            The enumeration is reset to the start of the data for this term.
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.TermDocs.Seek(Lucene.Net.Index.TermEnum)">
            <summary>Sets this to the data for the current term in a {@link TermEnum}.
            This may be optimized in some implementations.
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.TermDocs.Doc">
            <summary>Returns the current document number.  <p/> This is invalid until {@link
            #Next()} is called for the first time.
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.TermDocs.Freq">
            <summary>Returns the frequency of the term within the current document.  <p/> This
            is invalid until {@link #Next()} is called for the first time.
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.TermDocs.Next">
            <summary>Moves to the next pair in the enumeration.  <p/> Returns true iff there is
            such a next pair in the enumeration. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.TermDocs.Read(System.Int32[],System.Int32[])">
            <summary>Attempts to read multiple entries from the enumeration, up to length of
            <i>docs</i>.  Document numbers are stored in <i>docs</i>, and term
            frequencies are stored in <i>freqs</i>.  The <i>freqs</i> array must be as
            long as the <i>docs</i> array.
            
            <p/>Returns the number of entries read.  Zero is only returned when the
            stream has been exhausted.  
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.TermDocs.SkipTo(System.Int32)">
            <summary>Skips entries to the first beyond the current whose document number is
            greater than or equal to <i>target</i>. <p/>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.
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.TermDocs.Close">
            <summary>Frees associated resources. </summary>
        </member>
        <member name="M:Lucene.Net.Index.TermPositions.NextPosition">
            <summary>Returns next position in the current document.  It is an error to call
            this more than {@link #Freq()} times
            without calling {@link #Next()}<p/> This is
            invalid until {@link #Next()} is called for
            the first time.
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.TermPositions.GetPayloadLength">
            <summary> Returns the length of the payload at the current term position.
            This is invalid until {@link #NextPosition()} is called for
            the first time.<br/>
            </summary>
            <returns> length of the current payload in number of bytes
            </returns>
        </member>
        <member name="M:Lucene.Net.Index.TermPositions.GetPayload(System.Byte[],System.Int32)">
            <summary> Returns the payload data at the current term position.
            This is invalid until {@link #NextPosition()} is called for
            the first time.
            This method must not be called more than once after each call
            of {@link #NextPosition()}. However, payloads are loaded lazily,
            so if the payload data for the current position is not needed,
            this method may not be called at all for performance reasons.<br/>
            
            </summary>
            <param name="data">the array into which the data of this payload is to be
            stored, if it is big enough; otherwise, a new byte[] array
            is allocated for this purpose. 
            </param>
            <param name="offset">the offset in the array into which the data of this payload
            is to be stored.
            </param>
            <returns> a byte[] array containing the data of this payload
            </returns>
            <throws>  IOException </throws>
        </member>
        <member name="M:Lucene.Net.Index.TermPositions.IsPayloadAvailable">
            <summary> Checks if a payload can be loaded at this position.
            <p/>
            Payloads can only be loaded once per call to 
            {@link #NextPosition()}.
            
            </summary>
            <returns> true if there is a payload available at this position that can be loaded
            </returns>
        </member>
        <member name="T:Lucene.Net.Index.TermInfo">
            <summary>A TermInfo is the record of information stored for a term.</summary>
        </member>
        <member name="F:Lucene.Net.Index.TermInfo.docFreq">
            <summary>The number of documents which contain the term. </summary>
        </member>
        <member name="T:Lucene.Net.Index.Term">
            <summary>A Term represents a word from text.  This is the unit of search.  It is
            composed of two elements, the text of the word, as a string, and the name of
            the field that the text occured in, an interned string.
            Note that terms may represent more than words from text fields, but also
            things like dates, email addresses, urls, etc.  
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.Term.#ctor(System.String,System.String)">
            <summary>Constructs a Term with the given field and text.
            <p/>Note that a null field or null text value results in undefined
            behavior for most Lucene APIs that accept a Term parameter. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.Term.#ctor(System.String)">
            <summary>Constructs a Term with the given field and empty text.
            This serves two purposes: 1) reuse of a Term with the same field.
            2) pattern for a query.
            
            </summary>
            <param name="fld">
            </param>
        </member>
        <member name="M:Lucene.Net.Index.Term.Field">
            <summary>Returns the field of this term, an interned string.   The field indicates
            the part of a document which this term came from. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.Term.Text">
            <summary>Returns the text of this term.  In the case of words, this is simply the
            text of the word.  In the case of dates and other types, this is an
            encoding of the object as a string.  
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.Term.CreateTerm(System.String)">
            <summary> Optimized construction of new Terms by reusing same field as this Term
            - avoids field.intern() overhead 
            </summary>
            <param name="text">The text of the new term (field is implicitly same as this Term instance)
            </param>
            <returns> A new Term
            </returns>
        </member>
        <member name="M:Lucene.Net.Index.Term.CompareTo(Lucene.Net.Index.Term)">
            <summary>Compares two terms, returning a negative integer if this
            term belongs before the argument, zero if this term is equal to the
            argument, and a positive integer if this term belongs after the argument.
            The ordering of terms is first by field, then by text.
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.Term.Set(System.String,System.String)">
            <summary>Resets the field and text of a Term. </summary>
        </member>
        <member name="T:Lucene.Net.Index.ParallelReader">
            <summary>An IndexReader which reads multiple, parallel indexes.  Each index added
            must have the same number of documents, but typically each contains
            different fields.  Each document contains the union of the fields of all
            documents with the same document number.  When searching, matches for a
            query term are from the first index added that has the field.
            
            <p/>This is useful, e.g., with collections that have large fields which
            change rarely and small fields that change more frequently.  The smaller
            fields may be re-indexed in a new index and both indexes may be searched
            together.
            
            <p/><strong>Warning:</strong> It is up to you to make sure all indexes
            are created and modified the same way. For example, if you add
            documents to one index, you need to add the same documents in the
            same order to the other indexes. <em>Failure to do so will result in
            undefined behavior</em>.
            </summary>
        </member>
        <member name="T:Lucene.Net.Index.IndexReader">
            <summary>IndexReader is an abstract class, providing an interface for accessing an
            index.  Search of an index is done entirely through this abstract interface,
            so that any subclass which implements it is searchable.
            <p/> Concrete subclasses of IndexReader are usually constructed with a call to
            one of the static <code>open()</code> methods, e.g. {@link
            #Open(String, boolean)}.
            <p/> For efficiency, in this API documents are often referred to via
            <i>document numbers</i>, non-negative integers which each name a unique
            document in the index.  These document numbers are ephemeral--they may change
            as documents are added to and deleted from an index.  Clients should thus not
            rely on a given document having the same number between sessions.
            <p/> An IndexReader can be opened on a directory for which an IndexWriter is
            opened already, but it cannot be used to delete documents from the index then.
            <p/>
            <b>NOTE</b>: for backwards API compatibility, several methods are not listed 
            as abstract, but have no useful implementations in this base class and 
            instead always throw UnsupportedOperationException.  Subclasses are 
            strongly encouraged to override these methods, but in many cases may not 
            need to.
            <p/>
            <p/>
            <b>NOTE</b>: as of 2.4, it's possible to open a read-only
            IndexReader using one of the static open methods that
            accepts the boolean readOnly parameter.  Such a reader has
            better concurrency as it's not necessary to synchronize on
            the isDeleted method.  Currently the default for readOnly
            is false, meaning if not specified you will get a
            read/write IndexReader.  But in 3.0 this default will
            change to true, meaning you must explicitly specify false
            if you want to make changes with the resulting IndexReader.
            <p/>
            <a name="thread-safety"></a><p/><b>NOTE</b>: {@link
            <code>IndexReader</code>} instances are completely thread
            safe, meaning multiple threads can call any of its methods,
            concurrently.  If your application requires external
            synchronization, you should <b>not</b> synchronize on the
            <code>IndexReader</code> instance; use your own
            (non-Lucene) objects instead.
            </summary>
            <version>  $Id: IndexReader.java 826049 2009-10-16 19:28:55Z mikemccand $
            </version>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.GetRefCount">
            <summary>Expert: returns the current refCount for this reader </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.IncRef">
            <summary> Expert: increments the refCount of this IndexReader
            instance.  RefCounts are used to determine when a
            reader can be closed safely, i.e. as soon as there are
            no more references.  Be sure to always call a
            corresponding {@link #decRef}, in a finally clause;
            otherwise the reader may never be closed.  Note that
            {@link #close} simply calls decRef(), which means that
            the IndexReader will not really be closed until {@link
            #decRef} has been called for all outstanding
            references.
            
            </summary>
            <seealso cref="!:decRef">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.DecRef">
            <summary> Expert: decreases the refCount of this IndexReader
            instance.  If the refCount drops to 0, then pending
            changes (if any) are committed to the index and this
            reader is closed.
            
            </summary>
            <throws>  IOException in case an IOException occurs in commit() or doClose() </throws>
            <summary> 
            </summary>
            <seealso cref="!:incRef">
            </seealso>
        </member>
        <member name="F:Lucene.Net.Index.IndexReader.directory">
            <deprecated> will be deleted when IndexReader(Directory) is deleted
            </deprecated>
            <seealso cref="M:Lucene.Net.Index.IndexReader.Directory">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.#ctor(Lucene.Net.Store.Directory)">
            <summary> Legacy Constructor for backwards compatibility.
            
            <p/>
            This Constructor should not be used, it exists for backwards 
            compatibility only to support legacy subclasses that did not "own" 
            a specific directory, but needed to specify something to be returned 
            by the directory() method.  Future subclasses should delegate to the 
            no arg constructor and implement the directory() method as appropriate.
            
            </summary>
            <param name="directory">Directory to be returned by the directory() method
            </param>
            <seealso cref="M:Lucene.Net.Index.IndexReader.Directory">
            </seealso>
            <deprecated> - use IndexReader()
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.EnsureOpen">
            <throws>  AlreadyClosedException if this IndexReader is closed </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.Open(System.String)">
            <summary>Returns a read/write IndexReader reading the index in an FSDirectory in the named
            path.
            </summary>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  IOException if there is a low-level IO error </throws>
            <deprecated> Use {@link #Open(Directory, boolean)} instead. 
            This method will be removed in the 3.0 release.
            
            </deprecated>
            <param name="path">the path to the index directory 
            </param>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.Open(System.String,System.Boolean)">
            <summary>Returns an IndexReader reading the index in an
            FSDirectory in the named path.  You should pass
            readOnly=true, since it gives much better concurrent
            performance, unless you intend to do write operations
            (delete documents or change norms) with the reader.
            </summary>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  IOException if there is a low-level IO error </throws>
            <param name="path">the path to the index directory
            </param>
            <param name="readOnly">true if this should be a readOnly
            reader
            </param>
            <deprecated> Use {@link #Open(Directory, boolean)} instead.
            This method will be removed in the 3.0 release.
            
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.Open(System.IO.FileInfo)">
            <summary>Returns a read/write IndexReader reading the index in an FSDirectory in the named
            path.
            </summary>
            <param name="path">the path to the index directory
            </param>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  IOException if there is a low-level IO error </throws>
            <deprecated> Use {@link #Open(Directory, boolean)} instead.
            This method will be removed in the 3.0 release.
            
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.Open(System.IO.FileInfo,System.Boolean)">
            <summary>Returns an IndexReader reading the index in an
            FSDirectory in the named path.  You should pass
            readOnly=true, since it gives much better concurrent
            performance, unless you intend to do write operations
            (delete documents or change norms) with the reader.
            </summary>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  IOException if there is a low-level IO error </throws>
            <param name="path">the path to the index directory
            </param>
            <param name="readOnly">true if this should be a readOnly
            reader
            </param>
            <deprecated> Use {@link #Open(Directory, boolean)} instead.
            This method will be removed in the 3.0 release.
            
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.Open(Lucene.Net.Store.Directory)">
            <summary>Returns a read/write IndexReader reading the index in
            the given Directory.
            </summary>
            <param name="directory">the index directory
            </param>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  IOException if there is a low-level IO error </throws>
            <deprecated> Use {@link #Open(Directory, boolean)} instead
            This method will be removed in the 3.0 release.
            
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.Open(Lucene.Net.Store.Directory,System.Boolean)">
            <summary>Returns an IndexReader reading the index in the given
            Directory.  You should pass readOnly=true, since it
            gives much better concurrent performance, unless you
            intend to do write operations (delete documents or
            change norms) with the reader.
            </summary>
            <param name="directory">the index directory
            </param>
            <param name="readOnly">true if no changes (deletions, norms) will be made with this IndexReader
            </param>
            <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.IndexReader.Open(Lucene.Net.Index.IndexCommit)">
            <summary>Expert: returns a read/write IndexReader reading the index in the given
            {@link IndexCommit}.
            </summary>
            <param name="commit">the commit point to open
            </param>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <deprecated> Use {@link #Open(IndexCommit, boolean)} instead.
            This method will be removed in the 3.0 release.
            
            </deprecated>
            <throws>  IOException if there is a low-level IO error </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.Open(Lucene.Net.Index.IndexCommit,System.Boolean)">
            <summary>Expert: returns an IndexReader reading the index in the given
            {@link IndexCommit}.  You should pass readOnly=true, since it
            gives much better concurrent performance, unless you
            intend to do write operations (delete documents or
            change norms) with the reader.
            </summary>
            <param name="commit">the commit point to open
            </param>
            <param name="readOnly">true if no changes (deletions, norms) will be made with this IndexReader
            </param>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  IOException if there is a low-level IO error </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.Open(Lucene.Net.Store.Directory,Lucene.Net.Index.IndexDeletionPolicy)">
            <summary>Expert: returns a read/write IndexReader reading the index in the given
            Directory, with a custom {@link IndexDeletionPolicy}.
            </summary>
            <param name="directory">the index directory
            </param>
            <param name="deletionPolicy">a custom deletion policy (only used
            if you use this reader to perform deletes or to set
            norms); see {@link IndexWriter} for details.
            </param>
            <deprecated> Use {@link #Open(Directory, IndexDeletionPolicy, boolean)} instead.
            This method will be removed in the 3.0 release.
            
            </deprecated>
            <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.IndexReader.Open(Lucene.Net.Store.Directory,Lucene.Net.Index.IndexDeletionPolicy,System.Boolean)">
            <summary>Expert: returns an IndexReader reading the index in
            the given Directory, with a custom {@link
            IndexDeletionPolicy}.  You should pass readOnly=true,
            since it gives much better concurrent performance,
            unless you intend to do write operations (delete
            documents or change norms) with the reader.
            </summary>
            <param name="directory">the index directory
            </param>
            <param name="deletionPolicy">a custom deletion policy (only used
            if you use this reader to perform deletes or to set
            norms); see {@link IndexWriter} for details.
            </param>
            <param name="readOnly">true if no changes (deletions, norms) will be made with this IndexReader
            </param>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  IOException if there is a low-level IO error </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.Open(Lucene.Net.Store.Directory,Lucene.Net.Index.IndexDeletionPolicy,System.Boolean,System.Int32)">
            <summary>Expert: returns an IndexReader reading the index in
            the given Directory, with a custom {@link
            IndexDeletionPolicy}.  You should pass readOnly=true,
            since it gives much better concurrent performance,
            unless you intend to do write operations (delete
            documents or change norms) with the reader.
            </summary>
            <param name="directory">the index directory
            </param>
            <param name="deletionPolicy">a custom deletion policy (only used
            if you use this reader to perform deletes or to set
            norms); see {@link IndexWriter} for details.
            </param>
            <param name="readOnly">true if no changes (deletions, norms) will be made with this IndexReader
            </param>
            <param name="termInfosIndexDivisor">Subsamples which indexed
            terms are loaded into RAM. This has the same effect as {@link
            IndexWriter#setTermIndexInterval} except that setting
            must be done at indexing time while this setting can be
            set per reader.  When set to N, then one in every
            N*termIndexInterval terms in the index is loaded into
            memory.  By setting this to a value > 1 you can reduce
            memory usage, at the expense of higher latency when
            loading a TermInfo.  The default value is 1.  Set this
            to -1 to skip loading the terms index entirely.
            </param>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  IOException if there is a low-level IO error </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.Open(Lucene.Net.Index.IndexCommit,Lucene.Net.Index.IndexDeletionPolicy)">
            <summary>Expert: returns a read/write IndexReader reading the index in the given
            Directory, using a specific commit and with a custom
            {@link IndexDeletionPolicy}.
            </summary>
            <param name="commit">the specific {@link IndexCommit} to open;
            see {@link IndexReader#listCommits} to list all commits
            in a directory
            </param>
            <param name="deletionPolicy">a custom deletion policy (only used
            if you use this reader to perform deletes or to set
            norms); see {@link IndexWriter} for details.
            </param>
            <deprecated> Use {@link #Open(IndexCommit, IndexDeletionPolicy, boolean)} instead.
            This method will be removed in the 3.0 release.
            
            </deprecated>
            <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.IndexReader.Open(Lucene.Net.Index.IndexCommit,Lucene.Net.Index.IndexDeletionPolicy,System.Boolean)">
            <summary>Expert: returns an IndexReader reading the index in
            the given Directory, using a specific commit and with
            a custom {@link IndexDeletionPolicy}.  You should pass
            readOnly=true, since it gives much better concurrent
            performance, unless you intend to do write operations
            (delete documents or change norms) with the reader.
            </summary>
            <param name="commit">the specific {@link IndexCommit} to open;
            see {@link IndexReader#listCommits} to list all commits
            in a directory
            </param>
            <param name="deletionPolicy">a custom deletion policy (only used
            if you use this reader to perform deletes or to set
            norms); see {@link IndexWriter} for details.
            </param>
            <param name="readOnly">true if no changes (deletions, norms) will be made with this IndexReader
            </param>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  IOException if there is a low-level IO error </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.Open(Lucene.Net.Index.IndexCommit,Lucene.Net.Index.IndexDeletionPolicy,System.Boolean,System.Int32)">
            <summary>Expert: returns an IndexReader reading the index in
            the given Directory, using a specific commit and with
            a custom {@link IndexDeletionPolicy}.  You should pass
            readOnly=true, since it gives much better concurrent
            performance, unless you intend to do write operations
            (delete documents or change norms) with the reader.
            </summary>
            <param name="commit">the specific {@link IndexCommit} to open;
            see {@link IndexReader#listCommits} to list all commits
            in a directory
            </param>
            <param name="deletionPolicy">a custom deletion policy (only used
            if you use this reader to perform deletes or to set
            norms); see {@link IndexWriter} for details.
            </param>
            <param name="readOnly">true if no changes (deletions, norms) will be made with this IndexReader
            </param>
            <param name="termInfosIndexDivisor">Subsambles which indexed
            terms are loaded into RAM. This has the same effect as {@link
            IndexWriter#setTermIndexInterval} except that setting
            must be done at indexing time while this setting can be
            set per reader.  When set to N, then one in every
            N*termIndexInterval terms in the index is loaded into
            memory.  By setting this to a value > 1 you can reduce
            memory usage, at the expense of higher latency when
            loading a TermInfo.  The default value is 1.  Set this
            to -1 to skip loading the terms index entirely.
            </param>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  IOException if there is a low-level IO error </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.Reopen">
            <summary> Refreshes an IndexReader if the index has changed since this instance 
            was (re)opened. 
            <p/>
            Opening an IndexReader is an expensive operation. This method can be used
            to refresh an existing IndexReader to reduce these costs. This method 
            tries to only load segments that have changed or were created after the 
            IndexReader was (re)opened.
            <p/>
            If the index has not changed since this instance was (re)opened, then this
            call is a NOOP and returns this instance. Otherwise, a new instance is 
            returned. The old instance is <b>not</b> closed and remains usable.<br/>
            <p/>   
            If the reader is reopened, even though they share
            resources internally, it's safe to make changes
            (deletions, norms) with the new reader.  All shared
            mutable state obeys "copy on write" semantics to ensure
            the changes are not seen by other readers.
            <p/>
            You can determine whether a reader was actually reopened by comparing the
            old instance with the instance returned by this method: 
            <pre>
            IndexReader reader = ... 
            ...
            IndexReader newReader = r.reopen();
            if (newReader != reader) {
            ...     // reader was reopened
            reader.close(); 
            }
            reader = newReader;
            ...
            </pre>
            
            Be sure to synchronize that code so that other threads,
            if present, can never use reader after it has been
            closed and before it's switched to newReader.
            
            <p/><b>NOTE</b>: If this reader is a near real-time
            reader (obtained from {@link IndexWriter#GetReader()},
            reopen() will simply call writer.getReader() again for
            you, though this may change in the future.
            
            </summary>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  IOException if there is a low-level IO error </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.Reopen(System.Boolean)">
            <summary>Just like {@link #Reopen()}, except you can change the
            readOnly of the original reader.  If the index is
            unchanged but readOnly is different then a new reader
            will be returned. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.Reopen(Lucene.Net.Index.IndexCommit)">
            <summary>Expert: reopen this reader on a specific commit point.
            This always returns a readOnly reader.  If the
            specified commit point matches what this reader is
            already on, and this reader is already readOnly, then
            this same instance is returned; if it is not already
            readOnly, a readOnly clone is returned. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.Clone">
            <summary> Efficiently clones the IndexReader (sharing most
            internal state).
            <p/>
            On cloning a reader with pending changes (deletions,
            norms), the original reader transfers its write lock to
            the cloned reader.  This means only the cloned reader
            may make further changes to the index, and commit the
            changes to the index on close, but the old reader still
            reflects all changes made up until it was cloned.
            <p/>
            Like {@link #Reopen()}, it's safe to make changes to
            either the original or the cloned reader: all shared
            mutable state obeys "copy on write" semantics to ensure
            the changes are not seen by other readers.
            <p/>
            </summary>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  IOException if there is a low-level IO error </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.Clone(System.Boolean)">
            <summary> Clones the IndexReader and optionally changes readOnly.  A readOnly 
            reader cannot open a writeable reader.  
            </summary>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  IOException if there is a low-level IO error </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.Directory">
            <summary> Returns the directory associated with this index.  The Default 
            implementation returns the directory specified by subclasses when 
            delegating to the IndexReader(Directory) constructor, or throws an 
            UnsupportedOperationException if one was not specified.
            </summary>
            <throws>  UnsupportedOperationException if no directory </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.LastModified(System.String)">
            <summary> Returns the time the index in the named directory was last modified.
            Do not use this to check whether the reader is still up-to-date, use
            {@link #IsCurrent()} instead. 
            </summary>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  IOException if there is a low-level IO error </throws>
            <deprecated> Use {@link #LastModified(Directory)} instead.
            This method will be removed in the 3.0 release.
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.LastModified(System.IO.FileInfo)">
            <summary> Returns the time the index in the named directory was last modified. 
            Do not use this to check whether the reader is still up-to-date, use
            {@link #IsCurrent()} instead. 
            </summary>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  IOException if there is a low-level IO error </throws>
            <deprecated> Use {@link #LastModified(Directory)} instead.
            This method will be removed in the 3.0 release.
            
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.LastModified(Lucene.Net.Store.Directory)">
            <summary> Returns the time the index in the named directory was last modified. 
            Do not use this to check whether the reader is still up-to-date, use
            {@link #IsCurrent()} instead. 
            </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.IndexReader.GetCurrentVersion(System.String)">
            <summary> Reads version number from segments files. The version number is
            initialized with a timestamp and then increased by one for each change of
            the index.
            
            </summary>
            <param name="directory">where the index resides.
            </param>
            <returns> version number.
            </returns>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  IOException if there is a low-level IO error </throws>
            <deprecated> Use {@link #GetCurrentVersion(Directory)} instead.
            This method will be removed in the 3.0 release.
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.GetCurrentVersion(System.IO.FileInfo)">
            <summary> Reads version number from segments files. The version number is
            initialized with a timestamp and then increased by one for each change of
            the index.
            
            </summary>
            <param name="directory">where the index resides.
            </param>
            <returns> version number.
            </returns>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  IOException if there is a low-level IO error </throws>
            <deprecated> Use {@link #GetCurrentVersion(Directory)} instead.
            This method will be removed in the 3.0 release.
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.GetCurrentVersion(Lucene.Net.Store.Directory)">
            <summary> Reads version number from segments files. The version number is
            initialized with a timestamp and then increased by one for each change of
            the index.
            
            </summary>
            <param name="directory">where the index resides.
            </param>
            <returns> version number.
            </returns>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  IOException if there is a low-level IO error </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.GetCommitUserData(Lucene.Net.Store.Directory)">
            <summary> Reads commitUserData, previously passed to {@link
            IndexWriter#Commit(Map)}, from current index
            segments file.  This will return null if {@link
            IndexWriter#Commit(Map)} has never been called for
            this index.
            
            </summary>
            <param name="directory">where the index resides.
            </param>
            <returns> commit userData.
            </returns>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  IOException if there is a low-level IO error </throws>
            <summary> 
            </summary>
            <seealso cref="M:Lucene.Net.Index.IndexReader.GetCommitUserData">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.GetVersion">
            <summary> Version number when this IndexReader was opened. Not implemented in the
            IndexReader base class.
            
            <p/>
            If this reader is based on a Directory (ie, was created by calling
            {@link #Open}, or {@link #Reopen} on a reader based on a Directory), then
            this method returns the version recorded in the commit that the reader
            opened. This version is advanced every time {@link IndexWriter#Commit} is
            called.
            <p/>
            
            <p/>
            If instead this reader is a near real-time reader (ie, obtained by a call
            to {@link IndexWriter#GetReader}, or by calling {@link #Reopen} on a near
            real-time reader), then this method returns the version of the last
            commit done by the writer. Note that even as further changes are made
            with the writer, the version will not changed until a commit is
            completed. Thus, you should not rely on this method to determine when a
            near real-time reader should be opened. Use {@link #IsCurrent} instead.
            <p/>
            
            </summary>
            <throws>  UnsupportedOperationException </throws>
            <summary>             unless overridden in subclass
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.GetCommitUserData">
            <summary> Retrieve the String userData optionally passed to
            IndexWriter#commit.  This will return null if {@link
            IndexWriter#Commit(Map)} has never been called for
            this index.
            
            </summary>
            <seealso cref="M:Lucene.Net.Index.IndexReader.GetCommitUserData(Lucene.Net.Store.Directory)">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.SetTermInfosIndexDivisor(System.Int32)">
            <summary><p/>For IndexReader implementations that use
            TermInfosReader to read terms, this sets the
            indexDivisor to subsample the number of indexed terms
            loaded into memory.  This has the same effect as {@link
            IndexWriter#setTermIndexInterval} except that setting
            must be done at indexing time while this setting can be
            set per reader.  When set to N, then one in every
            N*termIndexInterval terms in the index is loaded into
            memory.  By setting this to a value > 1 you can reduce
            memory usage, at the expense of higher latency when
            loading a TermInfo.  The default value is 1.<p/>
            
            <b>NOTE:</b> you must call this before the term
            index is loaded.  If the index is already loaded, 
            an IllegalStateException is thrown.
            </summary>
            <throws>  IllegalStateException if the term index has already been loaded into memory </throws>
            <deprecated> Please use {@link IndexReader#Open(Directory, IndexDeletionPolicy, boolean, int)} to specify the required TermInfos index divisor instead.
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.GetTermInfosIndexDivisor">
            <summary><p/>For IndexReader implementations that use
            TermInfosReader to read terms, this returns the
            current indexDivisor as specified when the reader was
            opened.
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.IsCurrent">
            <summary> Check whether any new changes have occurred to the index since this
            reader was opened.
            
            <p/>
            If this reader is based on a Directory (ie, was created by calling
            {@link #open}, or {@link #reopen} on a reader based on a Directory), then
            this method checks if any further commits (see {@link IndexWriter#commit}
            have occurred in that directory).
            <p/>
            
            <p/>
            If instead this reader is a near real-time reader (ie, obtained by a call
            to {@link IndexWriter#getReader}, or by calling {@link #reopen} on a near
            real-time reader), then this method checks if either a new commmit has
            occurred, or any new uncommitted changes have taken place via the writer.
            Note that even if the writer has only performed merging, this method will
            still return false.
            <p/>
            
            <p/>
            In any event, if this returns false, you should call {@link #reopen} to
            get a new reader that sees the changes.
            <p/>
            
            </summary>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  IOException if there is a low-level IO error </throws>
            <throws>  UnsupportedOperationException unless overridden in subclass </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.IsOptimized">
            <summary> Checks is the index is optimized (if it has a single segment and 
            no deletions).  Not implemented in the IndexReader base class.
            </summary>
            <returns> <code>true</code> if the index is optimized; <code>false</code> otherwise
            </returns>
            <throws>  UnsupportedOperationException unless overridden in subclass </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.GetTermFreqVectors(System.Int32)">
            <summary> Return an array of term frequency vectors for the specified document.
            The array contains a vector for each vectorized field in the document.
            Each vector contains terms and frequencies for all terms in a given vectorized field.
            If no such fields existed, the method returns null. The term vectors that are
            returned may either be of type {@link TermFreqVector}
            or of type {@link TermPositionVector} if
            positions or offsets have been stored.
            
            </summary>
            <param name="docNumber">document for which term frequency vectors are returned
            </param>
            <returns> array of term frequency vectors. May be null if no term vectors have been
            stored for the specified document.
            </returns>
            <throws>  IOException if index cannot be accessed </throws>
            <seealso cref="T:Lucene.Net.Documents.Field.TermVector">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.GetTermFreqVector(System.Int32,System.String)">
            <summary> Return a term frequency vector for the specified document and field. The
            returned vector contains terms and frequencies for the terms in
            the specified field of this document, if the field had the storeTermVector
            flag set. If termvectors had been stored with positions or offsets, a 
            {@link TermPositionVector} is returned.
            
            </summary>
            <param name="docNumber">document for which the term frequency vector is returned
            </param>
            <param name="field">field for which the term frequency vector is returned.
            </param>
            <returns> term frequency vector May be null if field does not exist in the specified
            document or term vector was not stored.
            </returns>
            <throws>  IOException if index cannot be accessed </throws>
            <seealso cref="T:Lucene.Net.Documents.Field.TermVector">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.GetTermFreqVector(System.Int32,System.String,Lucene.Net.Index.TermVectorMapper)">
            <summary> Load the Term Vector into a user-defined data structure instead of relying on the parallel arrays of
            the {@link TermFreqVector}.
            </summary>
            <param name="docNumber">The number of the document to load the vector for
            </param>
            <param name="field">The name of the field to load
            </param>
            <param name="mapper">The {@link TermVectorMapper} to process the vector.  Must not be null
            </param>
            <throws>  IOException if term vectors cannot be accessed or if they do not exist on the field and doc. specified. </throws>
            <summary> 
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.GetTermFreqVector(System.Int32,Lucene.Net.Index.TermVectorMapper)">
            <summary> Map all the term vectors for all fields in a Document</summary>
            <param name="docNumber">The number of the document to load the vector for
            </param>
            <param name="mapper">The {@link TermVectorMapper} to process the vector.  Must not be null
            </param>
            <throws>  IOException if term vectors cannot be accessed or if they do not exist on the field and doc. specified. </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.IndexExists(System.String)">
            <summary> Returns <code>true</code> if an index exists at the specified directory.
            If the directory does not exist or if there is no index in it.
            <code>false</code> is returned.
            </summary>
            <param name="directory">the directory to check for an index
            </param>
            <returns> <code>true</code> if an index exists; <code>false</code> otherwise
            </returns>
            <deprecated> Use {@link #IndexExists(Directory)} instead
            This method will be removed in the 3.0 release.
            
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.IndexExists(System.IO.FileInfo)">
            <summary> Returns <code>true</code> if an index exists at the specified directory.
            If the directory does not exist or if there is no index in it.
            </summary>
            <param name="directory">the directory to check for an index
            </param>
            <returns> <code>true</code> if an index exists; <code>false</code> otherwise
            </returns>
            <deprecated> Use {@link #IndexExists(Directory)} instead.
            This method will be removed in the 3.0 release.
            
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.IndexExists(Lucene.Net.Store.Directory)">
            <summary> Returns <code>true</code> if an index exists at the specified directory.
            If the directory does not exist or if there is no index in it.
            </summary>
            <param name="directory">the directory to check for an index
            </param>
            <returns> <code>true</code> if an index exists; <code>false</code> otherwise
            </returns>
            <throws>  IOException if there is a problem with accessing the index </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.NumDocs">
            <summary>Returns the number of documents in this index. </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.MaxDoc">
            <summary>Returns one greater than the largest possible document number.
            This may be used to, e.g., determine how big to allocate an array which
            will have an element for every document number in an index.
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.NumDeletedDocs">
            <summary>Returns the number of deleted documents. </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.Document(System.Int32)">
            <summary> Returns the stored fields of the <code>n</code><sup>th</sup>
            <code>Document</code> in this index.
            <p/>
            <b>NOTE:</b> for performance reasons, this method does not check if the
            requested document is deleted, and therefore asking for a deleted document
            may yield unspecified results. Usually this is not required, however you
            can call {@link #IsDeleted(int)} with the requested document ID to verify
            the document is not deleted.
            
            </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.IndexReader.Document(System.Int32,Lucene.Net.Documents.FieldSelector)">
            <summary> Get the {@link Lucene.Net.Documents.Document} at the <code>n</code>
            <sup>th</sup> position. The {@link FieldSelector} may be used to determine
            what {@link Lucene.Net.Documents.Field}s to load and how they should
            be loaded. <b>NOTE:</b> If this Reader (more specifically, the underlying
            <code>FieldsReader</code>) is closed before the lazy
            {@link Lucene.Net.Documents.Field} is loaded an exception may be
            thrown. If you want the value of a lazy
            {@link Lucene.Net.Documents.Field} to be available after closing you
            must explicitly load it or fetch the Document again with a new loader.
            <p/>
            <b>NOTE:</b> for performance reasons, this method does not check if the
            requested document is deleted, and therefore asking for a deleted document
            may yield unspecified results. Usually this is not required, however you
            can call {@link #IsDeleted(int)} with the requested document ID to verify
            the document is not deleted.
            
            </summary>
            <param name="n">Get the document at the <code>n</code><sup>th</sup> position
            </param>
            <param name="fieldSelector">The {@link FieldSelector} to use to determine what
            Fields should be loaded on the Document. May be null, in which case
            all Fields will be loaded.
            </param>
            <returns> The stored fields of the
            {@link Lucene.Net.Documents.Document} at the nth position
            </returns>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  IOException if there is a low-level IO error </throws>
            <seealso cref="T:Lucene.Net.Documents.Fieldable">
            </seealso>
            <seealso cref="T:Lucene.Net.Documents.FieldSelector">
            </seealso>
            <seealso cref="T:Lucene.Net.Documents.SetBasedFieldSelector">
            </seealso>
            <seealso cref="T:Lucene.Net.Documents.LoadFirstFieldSelector">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.IsDeleted(System.Int32)">
            <summary>Returns true if document <i>n</i> has been deleted </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.HasDeletions">
            <summary>Returns true if any documents have been deleted </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.HasNorms(System.String)">
            <summary>Returns true if there are norms stored for this field. </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.Norms(System.String)">
            <summary>Returns the byte-encoded normalization factor for the named field of
            every document.  This is used by the search code to score documents.
            
            </summary>
            <seealso cref="!:Lucene.Net.Documents.Field.SetBoost(float)">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.Norms(System.String,System.Byte[],System.Int32)">
            <summary>Reads the byte-encoded normalization factor for the named field of every
            document.  This is used by the search code to score documents.
            
            </summary>
            <seealso cref="!:Lucene.Net.Documents.Field.SetBoost(float)">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.SetNorm(System.Int32,System.String,System.Byte)">
            <summary>Expert: Resets the normalization factor for the named field of the named
            document.  The norm represents the product of the field's {@link
            Lucene.Net.Documents.Fieldable#SetBoost(float) boost} and its {@link Similarity#LengthNorm(String,
            int) length normalization}.  Thus, to preserve the length normalization
            values when resetting this, one should base the new value upon the old.
            
            <b>NOTE:</b> If this field does not store norms, then
            this method call will silently do nothing.
            
            </summary>
            <seealso cref="M:Lucene.Net.Index.IndexReader.Norms(System.String)">
            </seealso>
            <seealso cref="M:Lucene.Net.Search.Similarity.DecodeNorm(System.Byte)">
            </seealso>
            <throws>  StaleReaderException if the index has changed </throws>
            <summary>  since this reader was opened
            </summary>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  LockObtainFailedException if another writer </throws>
            <summary>  has this index open (<code>write.lock</code> could not
            be obtained)
            </summary>
            <throws>  IOException if there is a low-level IO error </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.DoSetNorm(System.Int32,System.String,System.Byte)">
            <summary>Implements setNorm in subclass.</summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.SetNorm(System.Int32,System.String,System.Single)">
            <summary>Expert: Resets the normalization factor for the named field of the named
            document.
            
            </summary>
            <seealso cref="M:Lucene.Net.Index.IndexReader.Norms(System.String)">
            </seealso>
            <seealso cref="M:Lucene.Net.Search.Similarity.DecodeNorm(System.Byte)">
            
            </seealso>
            <throws>  StaleReaderException if the index has changed </throws>
            <summary>  since this reader was opened
            </summary>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  LockObtainFailedException if another writer </throws>
            <summary>  has this index open (<code>write.lock</code> could not
            be obtained)
            </summary>
            <throws>  IOException if there is a low-level IO error </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.Terms">
            <summary>Returns an enumeration of all the terms in the index. The
            enumeration is ordered by Term.compareTo(). Each term is greater
            than all that precede it in the enumeration. Note that after
            calling terms(), {@link TermEnum#Next()} must be called
            on the resulting enumeration before calling other methods such as
            {@link TermEnum#Term()}.
            </summary>
            <throws>  IOException if there is a low-level IO error </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.Terms(Lucene.Net.Index.Term)">
            <summary>Returns an enumeration of all terms starting at a given term. If
            the given term does not exist, the enumeration is positioned at the
            first term greater than the supplied term. The enumeration is
            ordered by Term.compareTo(). Each term is greater than all that
            precede it in the enumeration.
            </summary>
            <throws>  IOException if there is a low-level IO error </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.DocFreq(Lucene.Net.Index.Term)">
            <summary>Returns the number of documents containing the term <code>t</code>.</summary>
            <throws>  IOException if there is a low-level IO error </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.TermDocs(Lucene.Net.Index.Term)">
            <summary>Returns an enumeration of all the documents which contain
            <code>term</code>. For each document, the document number, the frequency of
            the term in that document is also provided, for use in
            search scoring.  If term is null, then all non-deleted
            docs are returned with freq=1.
            Thus, this method implements the mapping:
            <p/><ul>
            Term &#160;&#160; =&gt; &#160;&#160; &lt;docNum, freq&gt;<sup>*</sup>
            </ul>
            <p/>The enumeration is ordered by document number.  Each document number
            is greater than all that precede it in the enumeration.
            </summary>
            <throws>  IOException if there is a low-level IO error </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.TermDocs">
            <summary>Returns an unpositioned {@link TermDocs} enumerator.</summary>
            <throws>  IOException if there is a low-level IO error </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.TermPositions(Lucene.Net.Index.Term)">
            <summary>Returns an enumeration of all the documents which contain
            <code>term</code>.  For each document, in addition to the document number
            and frequency of the term in that document, a list of all of the ordinal
            positions of the term in the document is available.  Thus, this method
            implements the mapping:
            
            <p/><ul>
            Term &#160;&#160; =&gt; &#160;&#160; &lt;docNum, freq,
            &lt;pos<sub>1</sub>, pos<sub>2</sub>, ...
            pos<sub>freq-1</sub>&gt;
            &gt;<sup>*</sup>
            </ul>
            <p/> This positional information facilitates phrase and proximity searching.
            <p/>The enumeration is ordered by document number.  Each document number is
            greater than all that precede it in the enumeration.
            </summary>
            <throws>  IOException if there is a low-level IO error </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.TermPositions">
            <summary>Returns an unpositioned {@link TermPositions} enumerator.</summary>
            <throws>  IOException if there is a low-level IO error </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.DeleteDocument(System.Int32)">
            <summary>Deletes the document numbered <code>docNum</code>.  Once a document is
            deleted it will not appear in TermDocs or TermPostitions enumerations.
            Attempts to read its field with the {@link #document}
            method will result in an error.  The presence of this document may still be
            reflected in the {@link #docFreq} statistic, though
            this will be corrected eventually as the index is further modified.
            
            </summary>
            <throws>  StaleReaderException if the index has changed </throws>
            <summary> since this reader was opened
            </summary>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  LockObtainFailedException if another writer </throws>
            <summary>  has this index open (<code>write.lock</code> could not
            be obtained)
            </summary>
            <throws>  IOException if there is a low-level IO error </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.DoDelete(System.Int32)">
            <summary>Implements deletion of the document numbered <code>docNum</code>.
            Applications should call {@link #DeleteDocument(int)} or {@link #DeleteDocuments(Term)}.
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.DeleteDocuments(Lucene.Net.Index.Term)">
            <summary>Deletes all documents that have a given <code>term</code> indexed.
            This is useful if one uses a document field to hold a unique ID string for
            the document.  Then to delete such a document, one merely constructs a
            term with the appropriate field and the unique ID string as its text and
            passes it to this method.
            See {@link #DeleteDocument(int)} for information about when this deletion will 
            become effective.
            
            </summary>
            <returns> the number of documents deleted
            </returns>
            <throws>  StaleReaderException if the index has changed </throws>
            <summary>  since this reader was opened
            </summary>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  LockObtainFailedException if another writer </throws>
            <summary>  has this index open (<code>write.lock</code> could not
            be obtained)
            </summary>
            <throws>  IOException if there is a low-level IO error </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.UndeleteAll">
            <summary>Undeletes all documents currently marked as deleted in this index.
            
            </summary>
            <throws>  StaleReaderException if the index has changed </throws>
            <summary>  since this reader was opened
            </summary>
            <throws>  LockObtainFailedException if another writer </throws>
            <summary>  has this index open (<code>write.lock</code> could not
            be obtained)
            </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.IndexReader.DoUndeleteAll">
            <summary>Implements actual undeleteAll() in subclass. </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.AcquireWriteLock">
            <summary>Does nothing by default. Subclasses that require a write lock for
            index modifications must implement this method. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.Flush">
            <summary> </summary>
            <throws>  IOException </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.Flush(System.Collections.Generic.IDictionary{System.String,System.String})">
            <param name="commitUserData">Opaque Map (String -> String)
            that's recorded into the segments file in the index,
            and retrievable by {@link
            IndexReader#getCommitUserData}.
            </param>
            <throws>  IOException </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.Commit">
            <summary> Commit changes resulting from delete, undeleteAll, or
            setNorm operations
            
            If an exception is hit, then either no changes or all
            changes will have been committed to the index
            (transactional semantics).
            </summary>
            <throws>  IOException if there is a low-level IO error </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.Commit(System.Collections.Generic.IDictionary{System.String,System.String})">
            <summary> Commit changes resulting from delete, undeleteAll, or
            setNorm operations
            
            If an exception is hit, then either no changes or all
            changes will have been committed to the index
            (transactional semantics).
            </summary>
            <throws>  IOException if there is a low-level IO error </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.DoCommit">
            <summary>Implements commit.</summary>
            <deprecated> Please implement {@link #DoCommit(Map)
            instead}. 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.DoCommit(System.Collections.Generic.IDictionary{System.String,System.String})">
            <summary>Implements commit.  NOTE: subclasses should override
            this.  In 3.0 this will become an abstract method. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.Close">
            <summary> Closes files associated with this index.
            Also saves any new deletions to disk.
            No other methods should be called after this has been called.
            </summary>
            <throws>  IOException if there is a low-level IO error </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.Dispose">
            <summary>
            .NET
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.DoClose">
            <summary>Implements close. </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.GetFieldNames(Lucene.Net.Index.IndexReader.FieldOption)">
            <summary> Get a list of unique field names that exist in this index and have the specified
            field option information.
            </summary>
            <param name="fldOption">specifies which field option should be available for the returned fields
            </param>
            <returns> Collection of Strings indicating the names of the fields.
            </returns>
            <seealso cref="T:Lucene.Net.Index.IndexReader.FieldOption">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.IsLocked(Lucene.Net.Store.Directory)">
            <summary> Returns <code>true</code> iff the index in the named directory is
            currently locked.
            </summary>
            <param name="directory">the directory to check for a lock
            </param>
            <throws>  IOException if there is a low-level IO error </throws>
            <deprecated> Please use {@link IndexWriter#IsLocked(Directory)} instead.
            This method will be removed in the 3.0 release.
            
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.IsLocked(System.String)">
            <summary> Returns <code>true</code> iff the index in the named directory is
            currently locked.
            </summary>
            <param name="directory">the directory to check for a lock
            </param>
            <throws>  IOException if there is a low-level IO error </throws>
            <deprecated> Use {@link #IsLocked(Directory)} instead.
            This method will be removed in the 3.0 release.
            
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.Unlock(Lucene.Net.Store.Directory)">
            <summary> Forcibly unlocks the index in the named directory.
            <p/>
            Caution: this should only be used by failure recovery code,
            when it is known that no other process nor thread is in fact
            currently accessing this index.
            </summary>
            <deprecated> Please use {@link IndexWriter#Unlock(Directory)} instead.
            This method will be removed in the 3.0 release.
            
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.GetIndexCommit">
            <summary> Expert: return the IndexCommit that this reader has
            opened.  This method is only implemented by those
            readers that correspond to a Directory with its own
            segments_N file.
            
            <p/><b>WARNING</b>: this API is new and experimental and
            may suddenly change.<p/>
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.Main(System.String[])">
            <summary> Prints the filename and size of each file within a given compound file.
            Add the -extract flag to extract files to the current working directory.
            In order to make the extracted version of the index work, you have to copy
            the segments file from the compound index into the directory where the extracted files are stored.
            </summary>
            <param name="args">Usage: Lucene.Net.Index.IndexReader [-extract] &lt;cfsfile&gt;
            </param>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.ListCommits(Lucene.Net.Store.Directory)">
            <summary>Returns all commit points that exist in the Directory.
            Normally, because the default is {@link
            KeepOnlyLastCommitDeletionPolicy}, there would be only
            one commit point.  But if you're using a custom {@link
            IndexDeletionPolicy} then there could be many commits.
            Once you have a given commit, you can open a reader on
            it by calling {@link IndexReader#Open(IndexCommit)}
            There must be at least one commit in
            the Directory, else this method throws {@link
            java.io.IOException}.  Note that if a commit is in
            progress while this method is running, that commit
            may or may not be returned array.  
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.GetSequentialSubReaders">
            <summary>Expert: returns the sequential sub readers that this
            reader is logically composed of.  For example,
            IndexSearcher uses this API to drive searching by one
            sub reader at a time.  If this reader is not composed
            of sequential child readers, it should return null.
            If this method returns an empty array, that means this
            reader is a null reader (for example a MultiReader
            that has no sub readers).
            <p/>
            NOTE: You should not try using sub-readers returned by
            this method to make any changes (setNorm, deleteDocument,
            etc.). While this might succeed for one composite reader
            (like MultiReader), it will most likely lead to index
            corruption for other readers (like DirectoryReader obtained
            through {@link #open}. Use the parent reader directly. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.GetFieldCacheKey">
            <summary>Expert    </summary>
            <deprecated> 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.GetDeletesCacheKey">
            Expert.  Warning: this returns null if the reader has
            no deletions 
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.GetUniqueTermCount">
            <summary>Returns the number of unique terms (across all fields)
            in this reader.
            
            This method returns long, even though internally
            Lucene cannot handle more than 2^31 unique terms, for
            a possible future when this limitation is removed.
            
            </summary>
            <throws>  UnsupportedOperationException if this count </throws>
            <summary>  cannot be easily determined (eg Multi*Readers).
            Instead, you should call {@link
            #getSequentialSubReaders} and ask each sub reader for
            its unique term count. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.GetDisableFakeNorms">
            <summary>Expert: Return the state of the flag that disables fakes norms in favor of representing the absence of field norms with null.</summary>
            <returns> true if fake norms are disabled
            </returns>
            <deprecated> This currently defaults to false (to remain
            back-compatible), but in 3.0 it will be hardwired to
            true, meaning the norms() methods will return null for
            fields that had disabled norms.
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Index.IndexReader.SetDisableFakeNorms(System.Boolean)">
            <summary>Expert: Set the state of the flag that disables fakes norms in favor of representing the absence of field norms with null.</summary>
            <param name="disableFakeNorms">true to disable fake norms, false to preserve the legacy behavior
            </param>
            <deprecated> This currently defaults to false (to remain
            back-compatible), but in 3.0 it will be hardwired to
            true, meaning the norms() methods will return null for
            fields that had disabled norms.
            </deprecated>
        </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>
        <member name="T:Lucene.Net.Index.SegmentInfos">
            <summary> A collection of segmentInfo objects with methods for operating on
            those segments in relation to the file system.
            
            <p/><b>NOTE:</b> This API is new and still experimental
            (subject to change suddenly in the next release)<p/>
            </summary>
        </member>
        <member name="F:Lucene.Net.Index.SegmentInfos.FORMAT">
            <summary>The file format version, a negative number. </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.
            </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.
            </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. 
            </summary>
        </member>
        <member name="F:Lucene.Net.Index.SegmentInfos.FORMAT_CHECKSUM">
            <summary>This format adds a checksum at the end of the file to
            ensure all bytes were successfully written. 
            </summary>
        </member>
        <member name="F:Lucene.Net.Index.SegmentInfos.FORMAT_DEL_COUNT">
            <summary>This format adds the deletion count for each segment.
            This way IndexWriter can efficiently report numDocs(). 
            </summary>
        </member>
        <member name="F:Lucene.Net.Index.SegmentInfos.FORMAT_HAS_PROX">
            <summary>This format adds the boolean hasProx to record if any
            fields in the segment store prox information (ie, have
            omitTermFreqAndPositions==false) 
            </summary>
        </member>
        <member name="F:Lucene.Net.Index.SegmentInfos.FORMAT_USER_DATA">
            <summary>This format adds optional commit userData (String) storage. </summary>
        </member>
        <member name="F:Lucene.Net.Index.SegmentInfos.FORMAT_DIAGNOSTICS">
            <summary>This format adds optional per-segment String
            dianostics storage, and switches userData to Map 
            </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.
            </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>
        <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.
            
            </summary>
            <param name="files">-- array of file names to check
            </param>
        </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.
            
            </summary>
            <param name="directory">-- directory to search for the latest segments_N file
            </param>
        </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.
            
            </summary>
            <param name="files">-- array of file names to check
            </param>
        </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.
            
            </summary>
            <param name="directory">-- directory to search for the latest segments_N file
            </param>
        </member>
        <member name="M:Lucene.Net.Index.SegmentInfos.GetCurrentSegmentFileName">
            <summary> Get the segments_N filename in use by this segment infos.</summary>
        </member>
        <member name="M:Lucene.Net.Index.SegmentInfos.GenerationFromSegmentsFileName(System.String)">
            <summary> Parse the generation off the segments file name and
            return it.
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.SegmentInfos.GetNextSegmentFileName">
            <summary> Get the next segments_N filename that will be written.</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.
            
            </summary>
            <param name="directory">-- directory containing the segments file
            </param>
            <param name="segmentFileName">-- segment file to load
            </param>
            <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.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.
            </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.
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.SegmentInfos.GetVersion">
            <summary> version number when this SegmentInfos was generated.</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>
        <member name="M:Lucene.Net.Index.SegmentInfos.ReadCurrentUserData(Lucene.Net.Store.Directory)">
            <summary> Returns userData from latest segments file</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.SetInfoStream(System.IO.StreamWriter)">
            <summary>If non-null, information about retries when loading
            the segments file will be printed to this.
            </summary>
        </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>
        <member name="M:Lucene.Net.Index.SegmentInfos.GetDefaultGenFileRetryCount">
            <seealso cref="!:setDefaultGenFileRetryCount">
            </seealso>
        </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>
        <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>
        <member name="M:Lucene.Net.Index.SegmentInfos.GetInfoStream">
            <seealso cref="!:setInfoStream">
            </seealso>
        </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>
        <member name="M:Lucene.Net.Index.SegmentInfos.PrepareCommit(Lucene.Net.Store.Directory)">
            <summary>Call this to start a commit.  This writes the new
            segments file, but writes an invalid checksum at the
            end, so that it is not visible to readers.  Once this
            is called you must call {@link #finishCommit} to complete
            the commit or {@link #rollbackCommit} to abort it. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.SegmentInfos.Files(Lucene.Net.Store.Directory,System.Boolean)">
            <summary>Returns all file names referenced by SegmentInfo
            instances matching the provided Directory (ie files
            associated with any "external" segments are skipped).
            The returned collection is recomputed on each
            invocation.  
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.SegmentInfos.Commit(Lucene.Net.Store.Directory)">
            <summary>Writes &amp; syncs to the Directory dir, taking care to
            remove the segments file on exception 
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.SegmentInfos.Replace(Lucene.Net.Index.SegmentInfos)">
            <summary>Replaces all segments in this instance, but keeps
            generation, version, counter so that future commits
            remain write once.
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.SegmentInfos.Equals(System.Object)">
            <summary>
            Simple brute force implementation.
            If size is equal, compare items one by one.
            </summary>
            <param name="obj">SegmentInfos object to check equality for</param>
            <returns>true if lists are equal, false otherwise</returns>
        </member>
        <member name="M:Lucene.Net.Index.SegmentInfos.GetHashCode">
            <summary>
            Calculate hash code of SegmentInfos
            </summary>
            <returns>hash code as in java version of ArrayList</returns>
        </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>
        <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>
        <member name="T:Lucene.Net.Index.IndexReader.FieldOption">
            <summary> Constants describing field properties, for example used for
            {@link IndexReader#GetFieldNames(FieldOption)}.
            </summary>
        </member>
        <member name="F:Lucene.Net.Index.IndexReader.FieldOption.ALL">
            <summary>All fields </summary>
        </member>
        <member name="F:Lucene.Net.Index.IndexReader.FieldOption.INDEXED">
            <summary>All indexed fields </summary>
        </member>
        <member name="F:Lucene.Net.Index.IndexReader.FieldOption.STORES_PAYLOADS">
            <summary>All fields that store payloads </summary>
        </member>
        <member name="F:Lucene.Net.Index.IndexReader.FieldOption.OMIT_TERM_FREQ_AND_POSITIONS">
            <summary>All fields that omit tf </summary>
        </member>
        <member name="F:Lucene.Net.Index.IndexReader.FieldOption.OMIT_TF">
            <deprecated> Renamed to {@link #OMIT_TERM_FREQ_AND_POSITIONS} 
            </deprecated>
        </member>
        <member name="F:Lucene.Net.Index.IndexReader.FieldOption.UNINDEXED">
            <summary>All fields which are not indexed </summary>
        </member>
        <member name="F:Lucene.Net.Index.IndexReader.FieldOption.INDEXED_WITH_TERMVECTOR">
            <summary>All fields which are indexed with termvectors enabled </summary>
        </member>
        <member name="F:Lucene.Net.Index.IndexReader.FieldOption.INDEXED_NO_TERMVECTOR">
            <summary>All fields which are indexed but don't have termvectors enabled </summary>
        </member>
        <member name="F:Lucene.Net.Index.IndexReader.FieldOption.TERMVECTOR">
            <summary>All fields with termvectors enabled. Please note that only standard termvector fields are returned </summary>
        </member>
        <member name="F:Lucene.Net.Index.IndexReader.FieldOption.TERMVECTOR_WITH_POSITION">
            <summary>All fields with termvectors with position values enabled </summary>
        </member>
        <member name="F:Lucene.Net.Index.IndexReader.FieldOption.TERMVECTOR_WITH_OFFSET">
            <summary>All fields with termvectors with offset values enabled </summary>
        </member>
        <member name="F:Lucene.Net.Index.IndexReader.FieldOption.TERMVECTOR_WITH_POSITION_OFFSET">
            <summary>All fields with termvectors with offset values and position values enabled </summary>
        </member>
        <member name="M:Lucene.Net.Index.ParallelReader.#ctor">
            <summary>Construct a ParallelReader. 
            <p/>Note that all subreaders are closed if this ParallelReader is closed.<p/>
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.ParallelReader.#ctor(System.Boolean)">
            <summary>Construct a ParallelReader. </summary>
            <param name="closeSubReaders">indicates whether the subreaders should be closed
            when this ParallelReader is closed
            </param>
        </member>
        <member name="M:Lucene.Net.Index.ParallelReader.Add(Lucene.Net.Index.IndexReader)">
            <summary>Add an IndexReader.</summary>
            <throws>  IOException if there is a low-level IO error </throws>
        </member>
        <member name="M:Lucene.Net.Index.ParallelReader.Add(Lucene.Net.Index.IndexReader,System.Boolean)">
            <summary>Add an IndexReader whose stored fields will not be returned.  This can
            accellerate search when stored fields are only needed from a subset of
            the IndexReaders.
            
            </summary>
            <throws>  IllegalArgumentException if not all indexes contain the same number </throws>
            <summary>     of documents
            </summary>
            <throws>  IllegalArgumentException if not all indexes have the same value </throws>
            <summary>     of {@link IndexReader#MaxDoc()}
            </summary>
            <throws>  IOException if there is a low-level IO error </throws>
        </member>
        <member name="M:Lucene.Net.Index.ParallelReader.Reopen">
            <summary> Tries to reopen the subreaders.
            <br/>
            If one or more subreaders could be re-opened (i. e. subReader.reopen() 
            returned a new instance != subReader), then a new ParallelReader instance 
            is returned, otherwise this instance is returned.
            <p/>
            A re-opened instance might share one or more subreaders with the old 
            instance. Index modification operations result in undefined behavior
            when performed before the old instance is closed.
            (see {@link IndexReader#Reopen()}).
            <p/>
            If subreaders are shared, then the reference count of those
            readers is increased to ensure that the subreaders remain open
            until the last referring reader is closed.
            
            </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.ParallelReader.IsCurrent">
            <summary> Checks recursively if all subreaders are up to date. </summary>
        </member>
        <member name="M:Lucene.Net.Index.ParallelReader.IsOptimized">
            <summary> Checks recursively if all subindexes are optimized </summary>
        </member>
        <member name="M:Lucene.Net.Index.ParallelReader.GetVersion">
            <summary>Not implemented.</summary>
            <throws>  UnsupportedOperationException </throws>
        </member>
        <member name="M:Lucene.Net.Index.ParallelReader.DoCommit">
            <deprecated> 
            </deprecated>
        </member>
        <member name="T:Lucene.Net.Index.MergeDocIDRemapper">
            <summary>Remaps docIDs after a merge has completed, where the
            merged segments had at least one deletion.  This is used
            to renumber the buffered deletes in IndexWriter when a
            merge of segments with deletions commits. 
            </summary>
        </member>
        <member name="F:Lucene.Net.Index.IndexFileDeleter.VERBOSE_REF_COUNTS">
            <summary>Change to true to see details of reference counts when
            infoStream != null 
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexFileDeleter.#ctor(Lucene.Net.Store.Directory,Lucene.Net.Index.IndexDeletionPolicy,Lucene.Net.Index.SegmentInfos,System.IO.StreamWriter,Lucene.Net.Index.DocumentsWriter,System.Collections.Generic.Dictionary{System.String,System.String})">
            <summary> Initialize the deleter: find all previous commits in
            the Directory, incref the files they reference, call
            the policy to let it delete commits.  This will remove
            any files not referenced by any of the commits.
            </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.IndexFileDeleter.DeleteCommits">
            <summary> Remove the CommitPoints in the commitsToDelete List by
            DecRef'ing all files from each SegmentInfos.
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexFileDeleter.Refresh(System.String)">
            <summary> Writer calls this when it has hit an error and had to
            roll back, to tell us that there may now be
            unreferenced files in the filesystem.  So we re-list
            the filesystem and delete such files.  If segmentName
            is non-null, we will only delete files corresponding to
            that segment.
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexFileDeleter.Checkpoint(Lucene.Net.Index.SegmentInfos,System.Boolean)">
            <summary> For definition of "check point" see IndexWriter comments:
            "Clarification: Check Points (and commits)".
            
            Writer calls this when it has made a "consistent
            change" to the index, meaning new files are written to
            the index and the in-memory SegmentInfos have been
            modified to point to those files.
            
            This may or may not be a commit (segments_N may or may
            not have been written).
            
            We simply incref the files referenced by the new
            SegmentInfos and decref the files we had previously
            seen (if any).
            
            If this is a commit, we also call the policy to give it
            a chance to remove other commits.  If any commits are
            removed, we decref their files as well.
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexFileDeleter.DeleteNewFiles(System.Collections.Generic.ICollection{System.String})">
            <summary>Deletes the specified files, but only if they are new
            (have not yet been incref'd). 
            </summary>
        </member>
        <member name="T:Lucene.Net.Index.IndexFileDeleter.RefCount">
            <summary> Tracks the reference count for a single index file:</summary>
        </member>
        <member name="T:Lucene.Net.Index.IndexFileDeleter.CommitPoint">
            <summary> Holds details for each commit point.  This class is
            also passed to the deletion policy.  Note: this class
            has a natural ordering that is inconsistent with
            equals.
            </summary>
        </member>
        <member name="T:Lucene.Net.Index.IndexCommit">
            <summary> <p/>Expert: represents a single commit into an index as seen by the
            {@link IndexDeletionPolicy} or {@link IndexReader}.<p/>
            
            <p/> Changes to the content of an index are made visible
            only after the writer who made that change commits by
            writing a new segments file
            (<code>segments_N</code>). This point in time, when the
            action of writing of a new segments file to the directory
            is completed, is an index commit.<p/>
            
            <p/>Each index commit point has a unique segments file
            associated with it. The segments file associated with a
            later index commit point would have a larger N.<p/>
            
            <p/><b>WARNING</b>: This API is a new and experimental and
            may suddenly change. <p/>
            </summary>
        </member>
        <member name="T:Lucene.Net.Index.IndexCommitPoint">
            <deprecated> Please subclass IndexCommit class instead
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Index.IndexCommitPoint.GetSegmentsFileName">
            <summary> Get the segments file (<code>segments_N</code>) associated 
            with this commit point.
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexCommitPoint.GetFileNames">
            <summary> Returns all index files referenced by this commit point.</summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexCommitPoint.Delete">
            <summary> Delete this commit point.
            <p/>
            Upon calling this, the writer is notified that this commit 
            point should be deleted. 
            <p/>
            Decision that a commit-point should be deleted is taken by the {@link IndexDeletionPolicy} in effect
            and therefore this should only be called by its {@link IndexDeletionPolicy#onInit onInit()} or 
            {@link IndexDeletionPolicy#onCommit onCommit()} methods.
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexCommit.GetSegmentsFileName">
            <summary> Get the segments file (<code>segments_N</code>) associated 
            with this commit point.
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexCommit.GetFileNames">
            <summary> Returns all index files referenced by this commit point.</summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexCommit.GetDirectory">
            <summary> Returns the {@link Directory} for the index.</summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexCommit.Delete">
            <summary> Delete this commit point.  This only applies when using
            the commit point in the context of IndexWriter's
            IndexDeletionPolicy.
            <p/>
            Upon calling this, the writer is notified that this commit 
            point should be deleted. 
            <p/>
            Decision that a commit-point should be deleted is taken by the {@link IndexDeletionPolicy} in effect
            and therefore this should only be called by its {@link IndexDeletionPolicy#onInit onInit()} or 
            {@link IndexDeletionPolicy#onCommit onCommit()} methods.
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexCommit.IsOptimized">
            <summary> Returns true if this commit is an optimized index.</summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexCommit.Equals(System.Object)">
            <summary> Two IndexCommits are equal if both their Directory and versions are equal.</summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexCommit.GetVersion">
            <summary>Returns the version for this IndexCommit.  This is the
            same value that {@link IndexReader#getVersion} would
            return if it were opened on this commit. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexCommit.GetGeneration">
            <summary>Returns the generation (the _N in segments_N) for this
            IndexCommit 
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexCommit.GetTimestamp">
            <summary>Convenience method that returns the last modified time
            of the segments_N file corresponding to this index
            commit, equivalent to
            getDirectory().fileModified(getSegmentsFileName()). 
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexCommit.GetUserData">
            <summary>Returns userData, previously passed to {@link
            IndexWriter#Commit(Map)} for this commit.  Map is
            String -> String. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexFileDeleter.CommitPoint.Delete">
            <summary> Called only be the deletion policy, to remove this
            commit point from the index.
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.DocFieldConsumerPerField.ProcessFields(Lucene.Net.Documents.Fieldable[],System.Int32)">
            <summary>Processes all occurrences of a single field </summary>
        </member>
        <member name="T:Lucene.Net.Index.DocFieldConsumers">
            <summary>This is just a "splitter" class: it lets you wrap two
            DocFieldConsumer instances as a single consumer. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.DocFieldConsumer.Flush(System.Collections.IDictionary,Lucene.Net.Index.SegmentWriteState)">
            <summary>Called when DocumentsWriter decides to create a new
            segment 
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.DocFieldConsumer.CloseDocStore(Lucene.Net.Index.SegmentWriteState)">
            <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">
            <summary>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. 
            </summary>
        </member>
        <member name="T:Lucene.Net.Index.DocumentsWriter">
            <summary> 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.
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.DocumentsWriter.NewPerDocBuffer">
            Create and return a new DocWriterBuffer.
        </member>
        <member name="M:Lucene.Net.Index.DocumentsWriter.HasProx">
            <summary>Returns true if any of the fields in the current
            buffered docs have omitTermFreqAndPositions==false 
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.DocumentsWriter.SetInfoStream(System.IO.StreamWriter)">
            <summary>If non-null, various details of indexing are printed
            here. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.DocumentsWriter.SetRAMBufferSizeMB(System.Double)">
            <summary>Set how much RAM we can use before flushing. </summary>
        </member>
        <member name="M:Lucene.Net.Index.DocumentsWriter.SetMaxBufferedDocs(System.Int32)">
            <summary>Set max buffered docs, which means we will flush by
            doc count instead of by RAM usage. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.DocumentsWriter.GetSegment">
            <summary>Get current segment name we are writing. </summary>
        </member>
        <member name="M:Lucene.Net.Index.DocumentsWriter.GetNumDocsInRAM">
            <summary>Returns how many docs are currently buffered in RAM. </summary>
        </member>
        <member name="M:Lucene.Net.Index.DocumentsWriter.GetDocStoreSegment">
            <summary>Returns the current doc store segment we are writing
            to.  This will be the same as segment when autoCommit
            * is true. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.DocumentsWriter.GetDocStoreOffset">
            <summary>Returns the doc offset into the shared doc store for
            the current buffered docs. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.DocumentsWriter.CloseDocStore">
            <summary>Closes the current open doc stores an returns the doc
            store segment name.  This returns null if there are *
            no buffered documents. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.DocumentsWriter.Abort">
            <summary>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. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.DocumentsWriter.DoAfterFlush">
            <summary>Reset after a flush </summary>
        </member>
        <member name="M:Lucene.Net.Index.DocumentsWriter.Flush(System.Boolean)">
            <summary>Flush all pending docs to a new segment </summary>
        </member>
        <member name="M:Lucene.Net.Index.DocumentsWriter.CreateCompoundFile(System.String)">
            <summary>Build compound file for the segment we just flushed </summary>
        </member>
        <member name="M:Lucene.Net.Index.DocumentsWriter.SetFlushPending">
            <summary>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. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.DocumentsWriter.GetThreadState(Lucene.Net.Documents.Document,Lucene.Net.Index.Term)">
            <summary>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. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.DocumentsWriter.AddDocument(Lucene.Net.Documents.Document,Lucene.Net.Analysis.Analyzer)">
            <summary>Returns true if the caller (IndexWriter) should now
            flush. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.DocumentsWriter.RemapDeletes(Lucene.Net.Index.SegmentInfos,System.Int32[][],System.Int32[],Lucene.Net.Index.MergePolicy.OneMerge,System.Int32)">
            <summary>Called whenever a merge has completed and the merged segments had deletions </summary>
        </member>
        <member name="M:Lucene.Net.Index.DocumentsWriter.FinishDocument(Lucene.Net.Index.DocumentsWriterThreadState,Lucene.Net.Index.DocumentsWriter.DocWriter)">
            <summary>Does the synchronized work to finish/flush the
            inverted document. 
            </summary>
        </member>
        <member name="T:Lucene.Net.Index.DocumentsWriter.IndexingChain">
            <summary> The IndexingChain must define the {@link #GetChain(DocumentsWriter)} method
            which returns the DocConsumer that the DocumentsWriter calls to process the
            documents. 
            </summary>
        </member>
        <member name="T:Lucene.Net.Index.DocumentsWriter.DocWriter">
            <summary>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. 
            </summary>
        </member>
        <member name="T:Lucene.Net.Index.DocumentsWriter.PerDocBuffer">
            RAMFile buffer for DocWriters.
        </member>
        <member name="M:Lucene.Net.Store.RAMFile.NewBuffer(System.Int32)">
            <summary> Expert: allocate a new buffer. 
            Subclasses can allocate differently. 
            </summary>
            <param name="size">size of allocated buffer.
            </param>
            <returns> allocated buffer.
            </returns>
        </member>
        <member name="M:Lucene.Net.Index.DocumentsWriter.PerDocBuffer.NewBuffer(System.Int32)">
            Allocate bytes used from shared pool.
        </member>
        <member name="M:Lucene.Net.Index.DocumentsWriter.PerDocBuffer.Recycle">
            Recycle the bytes used.
        </member>
        <member name="T:Lucene.Net.Index.DirectoryOwningReader">
            <summary> This class keeps track of closing the underlying directory. It is used to wrap
            DirectoryReaders, that are created using a String/File parameter
            in IndexReader.open() with FSDirectory.getDirectory().
            </summary>
            <deprecated> This helper class is removed with all String/File
            IndexReader.open() methods in Lucene 3.0
            </deprecated>
        </member>
        <member name="T:Lucene.Net.Index.FilterIndexReader">
            <summary>A <code>FilterIndexReader</code> contains another IndexReader, which it
            uses as its basic source of data, possibly transforming the data along the
            way or providing additional functionality. The class
            <code>FilterIndexReader</code> itself simply implements all abstract methods
            of <code>IndexReader</code> with versions that pass all requests to the
            contained index reader. Subclasses of <code>FilterIndexReader</code> may
            further override some of these methods and may also provide additional
            methods and fields.
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.FilterIndexReader.#ctor(Lucene.Net.Index.IndexReader)">
            <summary> <p/>Construct a FilterIndexReader based on the specified base reader.
            Directory locking for delete, undeleteAll, and setNorm operations is
            left to the base reader.<p/>
            <p/>Note that base reader is closed if this FilterIndexReader is closed.<p/>
            </summary>
            <param name="in">specified base reader.
            </param>
        </member>
        <member name="M:Lucene.Net.Index.FilterIndexReader.DoCommit">
            <deprecated> 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Index.FilterIndexReader.GetFieldCacheKey">
             <summary>
             If the subclass of FilteredIndexReader modifies the
             contents of the FieldCache, you must override this
             method to provide a different key */
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.FilterIndexReader.GetDeletesCacheKey">
            <summary>
            If the subclass of FilteredIndexReader modifies the
            deleted docs, you must override this method to provide
            a different key */
            </summary>
        </member>
        <member name="T:Lucene.Net.Index.FilterIndexReader.FilterTermDocs">
            <summary>Base class for filtering {@link TermDocs} implementations. </summary>
        </member>
        <member name="T:Lucene.Net.Index.FilterIndexReader.FilterTermPositions">
            <summary>Base class for filtering {@link TermPositions} implementations. </summary>
        </member>
        <member name="T:Lucene.Net.Index.FilterIndexReader.FilterTermEnum">
            <summary>Base class for filtering {@link TermEnum} implementations. </summary>
        </member>
        <member name="F:Lucene.Net.Index.DirectoryOwningReader.ref_Renamed">
            <summary> This member contains the ref counter, that is passed to each instance after cloning/reopening,
            and is global to all DirectoryOwningReader derived from the original one.
            This reuses the class {@link SegmentReader.Ref}
            </summary>
        </member>
        <member name="T:Lucene.Net.Documents.DateTools">
            <summary> Provides support for converting dates to strings and vice-versa.
            The strings are structured so that lexicographic sorting orders 
            them by date, which makes them suitable for use as field values 
            and search terms.
            
            <p/>This class also helps you to limit the resolution of your dates. Do not
            save dates with a finer resolution than you really need, as then
            RangeQuery and PrefixQuery will require more memory and become slower.
            
            <p/>Compared to {@link DateField} the strings generated by the methods
            in this class take slightly more space, unless your selected resolution
            is set to <code>Resolution.DAY</code> or lower.
            
            <p/>
            Another approach is {@link NumericUtils}, which provides
            a sortable binary representation (prefix encoded) of numeric values, which
            date/time are.
            For indexing a {@link Date} or {@link Calendar}, just get the unix timestamp as
            <code>long</code> using {@link Date#getTime} or {@link Calendar#getTimeInMillis} and
            index this as a numeric value with {@link NumericField}
            and use {@link NumericRangeQuery} to query it.
            </summary>
        </member>
        <member name="M:Lucene.Net.Documents.DateTools.DateToString(System.DateTime,Lucene.Net.Documents.DateTools.Resolution)">
            <summary> Converts a Date to a string suitable for indexing.
            
            </summary>
            <param name="date">the date to be converted
            </param>
            <param name="resolution">the desired resolution, see
            {@link #Round(Date, DateTools.Resolution)}
            </param>
            <returns> a string in format <code>yyyyMMddHHmmssSSS</code> or shorter,
            depending on <code>resolution</code>; using GMT as timezone 
            </returns>
        </member>
        <member name="M:Lucene.Net.Documents.DateTools.TimeToString(System.Int64,Lucene.Net.Documents.DateTools.Resolution)">
            <summary> Converts a millisecond time to a string suitable for indexing.
            
            </summary>
            <param name="time">the date expressed as milliseconds since January 1, 1970, 00:00:00 GMT
            </param>
            <param name="resolution">the desired resolution, see
            {@link #Round(long, DateTools.Resolution)}
            </param>
            <returns> a string in format <code>yyyyMMddHHmmssSSS</code> or shorter,
            depending on <code>resolution</code>; using GMT as timezone
            </returns>
        </member>
        <member name="M:Lucene.Net.Documents.DateTools.StringToTime(System.String)">
            <summary> Converts a string produced by <code>timeToString</code> or
            <code>DateToString</code> back to a time, represented as the
            number of milliseconds since January 1, 1970, 00:00:00 GMT.
            
            </summary>
            <param name="dateString">the date string to be converted
            </param>
            <returns> the number of milliseconds since January 1, 1970, 00:00:00 GMT
            </returns>
            <throws>  ParseException if <code>dateString</code> is not in the  </throws>
            <summary>  expected format 
            </summary>
        </member>
        <member name="M:Lucene.Net.Documents.DateTools.StringToDate(System.String)">
            <summary> Converts a string produced by <code>timeToString</code> or
            <code>DateToString</code> back to a time, represented as a
            Date object.
            
            </summary>
            <param name="dateString">the date string to be converted
            </param>
            <returns> the parsed time as a Date object 
            </returns>
            <throws>  ParseException if <code>dateString</code> is not in the  </throws>
            <summary>  expected format 
            </summary>
        </member>
        <member name="M:Lucene.Net.Documents.DateTools.Round(System.DateTime,Lucene.Net.Documents.DateTools.Resolution)">
            <summary> Limit a date's resolution. For example, the date <code>2004-09-21 13:50:11</code>
            will be changed to <code>2004-09-01 00:00:00</code> when using
            <code>Resolution.MONTH</code>. 
            
            </summary>
            <param name="resolution">The desired resolution of the date to be returned
            </param>
            <returns> the date with all values more precise than <code>resolution</code>
            set to 0 or 1
            </returns>
        </member>
        <member name="M:Lucene.Net.Documents.DateTools.Round(System.Int64,Lucene.Net.Documents.DateTools.Resolution)">
            <summary> Limit a date's resolution. For example, the date <code>1095767411000</code>
            (which represents 2004-09-21 13:50:11) will be changed to 
            <code>1093989600000</code> (2004-09-01 00:00:00) when using
            <code>Resolution.MONTH</code>.
            
            </summary>
            <param name="time">The time in milliseconds (not ticks).</param>
            <param name="resolution">The desired resolution of the date to be returned
            </param>
            <returns> the date with all values more precise than <code>resolution</code>
            set to 0 or 1, expressed as milliseconds since January 1, 1970, 00:00:00 GMT
            </returns>
        </member>
        <member name="T:Lucene.Net.Documents.DateTools.Resolution">
            <summary>Specifies the time granularity. </summary>
        </member>
        <member name="T:Lucene.Net.Analysis.Tokenattributes.TypeAttributeImpl">
            <summary> A Token's lexical type. The Default value is "word". </summary>
        </member>
        <member name="T:Lucene.Net.Util.AttributeImpl">
            <summary> Base class for Attributes that can be added to a 
            {@link Lucene.Net.Util.AttributeSource}.
            <p/>
            Attributes are used to add data in a dynamic, yet type-safe way to a source
            of usually streamed objects, e. g. a {@link Lucene.Net.Analysis.TokenStream}.
            </summary>
        </member>
        <member name="T:Lucene.Net.Util.Attribute">
            <summary> Base interface for attributes.</summary>
        </member>
        <member name="M:Lucene.Net.Util.AttributeImpl.Clear">
            <summary> Clears the values in this AttributeImpl and resets it to its 
            default value. If this implementation implements more than one Attribute interface
            it clears all.
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.AttributeImpl.ToString">
            <summary> The default implementation of this method accesses all declared
            fields of this object and prints the values in the following syntax:
            
            <pre>
            public String toString() {
            return "start=" + startOffset + ",end=" + endOffset;
            }
            </pre>
            
            This method may be overridden by subclasses.
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.AttributeImpl.GetHashCode">
            <summary> Subclasses must implement this method and should compute
            a hashCode similar to this:
            <pre>
            public int hashCode() {
            int code = startOffset;
            code = code * 31 + endOffset;
            return code;
            }
            </pre> 
            
            see also {@link #equals(Object)}
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.AttributeImpl.Equals(System.Object)">
            <summary> All values used for computation of {@link #hashCode()} 
            should be checked here for equality.
            
            see also {@link Object#equals(Object)}
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.AttributeImpl.CopyTo(Lucene.Net.Util.AttributeImpl)">
            <summary> Copies the values from this Attribute into the passed-in
            target attribute. The target implementation must support all the
            Attributes this implementation supports.
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.AttributeImpl.Clone">
            <summary> Shallow clone. Subclasses must override this if they 
            need to clone any members deeply,
            </summary>
        </member>
        <member name="T:Lucene.Net.Analysis.Tokenattributes.TypeAttribute">
            <summary> A Token's lexical type. The Default value is "word". </summary>
        </member>
        <member name="M:Lucene.Net.Analysis.Tokenattributes.TypeAttribute.Type">
            <summary>Returns this Token's lexical type.  Defaults to "word". </summary>
        </member>
        <member name="M:Lucene.Net.Analysis.Tokenattributes.TypeAttribute.SetType(System.String)">
            <summary>Set the lexical type.</summary>
            <seealso cref="M:Lucene.Net.Analysis.Tokenattributes.TypeAttribute.Type">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Analysis.Tokenattributes.TypeAttributeImpl.Type">
            <summary>Returns this Token's lexical type.  Defaults to "word". </summary>
        </member>
        <member name="M:Lucene.Net.Analysis.Tokenattributes.TypeAttributeImpl.SetType(System.String)">
            <summary>Set the lexical type.</summary>
            <seealso cref="M:Lucene.Net.Analysis.Tokenattributes.TypeAttributeImpl.Type">
            </seealso>
        </member>
        <member name="T:Lucene.Net.Analysis.StopFilter">
            <summary> Removes stop words from a token stream.</summary>
        </member>
        <member name="T:Lucene.Net.Analysis.TokenFilter">
            <summary> A TokenFilter is a TokenStream whose input is another TokenStream.
            <p/>
            This is an abstract class; subclasses must override {@link #IncrementToken()}.
            
            </summary>
            <seealso cref="T:Lucene.Net.Analysis.TokenStream">
            </seealso>
        </member>
        <member name="T:Lucene.Net.Analysis.TokenStream">
            <summary> A <code>TokenStream</code> enumerates the sequence of tokens, either from
            {@link Field}s of a {@link Document} or from query text.
            <p/>
            This is an abstract class. Concrete subclasses are:
            <ul>
            <li>{@link Tokenizer}, a <code>TokenStream</code> whose input is a Reader; and</li>
            <li>{@link TokenFilter}, a <code>TokenStream</code> whose input is another
            <code>TokenStream</code>.</li>
            </ul>
            A new <code>TokenStream</code> API has been introduced with Lucene 2.9. This API
            has moved from being {@link Token} based to {@link Attribute} based. While
            {@link Token} still exists in 2.9 as a convenience class, the preferred way
            to store the information of a {@link Token} is to use {@link AttributeImpl}s.
            <p/>
            <code>TokenStream</code> now extends {@link AttributeSource}, which provides
            access to all of the token {@link Attribute}s for the <code>TokenStream</code>.
            Note that only one instance per {@link AttributeImpl} is created and reused
            for every token. This approach reduces object creation and allows local
            caching of references to the {@link AttributeImpl}s. See
            {@link #IncrementToken()} for further details.
            <p/>
            <b>The workflow of the new <code>TokenStream</code> API is as follows:</b>
            <ol>
            <li>Instantiation of <code>TokenStream</code>/{@link TokenFilter}s which add/get
            attributes to/from the {@link AttributeSource}.</li>
            <li>The consumer calls {@link TokenStream#Reset()}.</li>
            <li>The consumer retrieves attributes from the stream and stores local
            references to all attributes it wants to access</li>
            <li>The consumer calls {@link #IncrementToken()} until it returns false and
            consumes the attributes after each call.</li>
            <li>The consumer calls {@link #End()} so that any end-of-stream operations
            can be performed.</li>
            <li>The consumer calls {@link #Close()} to release any resource when finished
            using the <code>TokenStream</code></li>
            </ol>
            To make sure that filters and consumers know which attributes are available,
            the attributes must be added during instantiation. Filters and consumers are
            not required to check for availability of attributes in
            {@link #IncrementToken()}.
            <p/>
            You can find some example code for the new API in the analysis package level
            Javadoc.
            <p/>
            Sometimes it is desirable to capture a current state of a <code>TokenStream</code>
            , e. g. for buffering purposes (see {@link CachingTokenFilter},
            {@link TeeSinkTokenFilter}). For this usecase
            {@link AttributeSource#CaptureState} and {@link AttributeSource#RestoreState}
            can be used.
            </summary>
        </member>
        <member name="T:Lucene.Net.Util.AttributeSource">
            <summary> An AttributeSource contains a list of different {@link AttributeImpl}s,
            and methods to add and get them. There can only be a single instance
            of an attribute in the same AttributeSource instance. This is ensured
            by passing in the actual type of the Attribute (Class&lt;Attribute&gt;) to 
            the {@link #AddAttribute(Class)}, which then checks if an instance of
            that type is already present. If yes, it returns the instance, otherwise
            it creates a new instance and returns it.
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.AttributeSource.#ctor">
            <summary> An AttributeSource using the default attribute factory {@link AttributeSource.AttributeFactory#DEFAULT_ATTRIBUTE_FACTORY}.</summary>
        </member>
        <member name="M:Lucene.Net.Util.AttributeSource.#ctor(Lucene.Net.Util.AttributeSource)">
            <summary> An AttributeSource that uses the same attributes as the supplied one.</summary>
        </member>
        <member name="M:Lucene.Net.Util.AttributeSource.#ctor(Lucene.Net.Util.AttributeSource.AttributeFactory)">
            <summary> An AttributeSource using the supplied {@link AttributeFactory} for creating new {@link Attribute} instances.</summary>
        </member>
        <member name="M:Lucene.Net.Util.AttributeSource.GetAttributeFactory">
            <summary> returns the used AttributeFactory.</summary>
        </member>
        <member name="M:Lucene.Net.Util.AttributeSource.GetAttributeClassesIterator">
             <summary>Returns a new iterator that iterates the attribute classes
             in the same order they were added in.
             Signature for Java 1.5: <code>public Iterator&lt;Class&lt;? extends Attribute&gt;&gt; getAttributeClassesIterator()</code>
            
             Note that this return value is different from Java in that it enumerates over the values
             and not the keys
             </summary>
        </member>
        <member name="M:Lucene.Net.Util.AttributeSource.GetAttributeImplsIterator">
            <summary>Returns a new iterator that iterates all unique Attribute implementations.
            This iterator may contain less entries that {@link #getAttributeClassesIterator},
            if one instance implements more than one Attribute interface.
            Signature for Java 1.5: <code>public Iterator&lt;AttributeImpl&gt; getAttributeImplsIterator()</code>
            </summary>
        </member>
        <member name="F:Lucene.Net.Util.AttributeSource.knownImplClasses">
            <summary>a cache that stores all interfaces for known implementation classes for performance (slow reflection) </summary>
        </member>
        <member name="M:Lucene.Net.Util.AttributeSource.AddAttributeImpl(Lucene.Net.Util.AttributeImpl)">
            <summary>Adds a custom AttributeImpl instance with one or more Attribute interfaces. </summary>
        </member>
        <member name="M:Lucene.Net.Util.AttributeSource.AddAttribute(System.Type)">
            <summary> The caller must pass in a Class&lt;? extends Attribute&gt; value.
            This method first checks if an instance of that class is 
            already in this AttributeSource and returns it. Otherwise a
            new instance is created, added to this AttributeSource and returned. 
            Signature for Java 1.5: <code>public &lt;T extends Attribute&gt; T addAttribute(Class&lt;T&gt;)</code>
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.AttributeSource.HasAttributes">
            <summary>Returns true, iff this AttributeSource has any attributes </summary>
        </member>
        <member name="M:Lucene.Net.Util.AttributeSource.HasAttribute(System.Type)">
            <summary> The caller must pass in a Class&lt;? extends Attribute&gt; value. 
            Returns true, iff this AttributeSource contains the passed-in Attribute.
            Signature for Java 1.5: <code>public boolean hasAttribute(Class&lt;? extends Attribute&gt;)</code>
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.AttributeSource.GetAttribute(System.Type)">
            <summary> The caller must pass in a Class&lt;? extends Attribute&gt; value. 
            Returns the instance of the passed in Attribute contained in this AttributeSource
            Signature for Java 1.5: <code>public &lt;T extends Attribute&gt; T getAttribute(Class&lt;T&gt;)</code>
            
            </summary>
            <throws>  IllegalArgumentException if this AttributeSource does not contain the </throws>
            <summary>         Attribute. It is recommended to always use {@link #addAttribute} even in consumers
            of TokenStreams, because you cannot know if a specific TokenStream really uses
            a specific Attribute. {@link #addAttribute} will automatically make the attribute
            available. If you want to only use the attribute, if it is available (to optimize
            consuming), use {@link #hasAttribute}.
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.AttributeSource.ClearAttributes">
            <summary> Resets all Attributes in this AttributeSource by calling
            {@link AttributeImpl#Clear()} on each Attribute implementation.
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.AttributeSource.CaptureState">
            <summary> Captures the state of all Attributes. The return value can be passed to
            {@link #restoreState} to restore the state of this or another AttributeSource.
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.AttributeSource.RestoreState(Lucene.Net.Util.AttributeSource.State)">
            <summary> Restores this state by copying the values of all attribute implementations
            that this state contains into the attributes implementations of the targetStream.
            The targetStream must contain a corresponding instance for each argument
            contained in this state (e.g. it is not possible to restore the state of
            an AttributeSource containing a TermAttribute into a AttributeSource using
            a Token instance as implementation).
            
            Note that this method does not affect attributes of the targetStream
            that are not contained in this state. In other words, if for example
            the targetStream contains an OffsetAttribute, but this state doesn't, then
            the value of the OffsetAttribute remains unchanged. It might be desirable to
            reset its value to the default, in which case the caller should first
            call {@link TokenStream#ClearAttributes()} on the targetStream.   
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.AttributeSource.CloneAttributes">
            <summary> Performs a clone of all {@link AttributeImpl} instances returned in a new
            AttributeSource instance. This method can be used to e.g. create another TokenStream
            with exactly the same attributes (using {@link #AttributeSource(AttributeSource)})
            </summary>
        </member>
        <member name="T:Lucene.Net.Util.AttributeSource.AttributeFactory">
            <summary> An AttributeFactory creates instances of {@link AttributeImpl}s.</summary>
        </member>
        <member name="M:Lucene.Net.Util.AttributeSource.AttributeFactory.CreateAttributeInstance(System.Type)">
            <summary> returns an {@link AttributeImpl} for the supplied {@link Attribute} interface class.
            <p/>Signature for Java 1.5: <code>public AttributeImpl createAttributeInstance(Class%lt;? extends Attribute&gt; attClass)</code>
            </summary>
        </member>
        <member name="F:Lucene.Net.Util.AttributeSource.AttributeFactory.DEFAULT_ATTRIBUTE_FACTORY">
            <summary> This is the default factory that creates {@link AttributeImpl}s using the
            class name of the supplied {@link Attribute} interface class by appending <code>Impl</code> to it.
            </summary>
        </member>
        <member name="T:Lucene.Net.Util.AttributeSource.State">
            <summary> This class holds the state of an AttributeSource.</summary>
            <seealso cref="!:captureState">
            </seealso>
            <seealso cref="!:restoreState">
            </seealso>
        </member>
        <member name="F:Lucene.Net.Analysis.TokenStream.DEFAULT_TOKEN_WRAPPER_ATTRIBUTE_FACTORY">
            <deprecated> Remove this when old API is removed! 
            </deprecated>
        </member>
        <member name="F:Lucene.Net.Analysis.TokenStream.tokenWrapper">
            <deprecated> Remove this when old API is removed! 
            </deprecated>
        </member>
        <member name="F:Lucene.Net.Analysis.TokenStream.onlyUseNewAPI">
            <deprecated> Remove this when old API is removed! 
            </deprecated>
        </member>
        <member name="F:Lucene.Net.Analysis.TokenStream.supportedMethods">
            <deprecated> Remove this when old API is removed! 
            </deprecated>
        </member>
        <member name="F:Lucene.Net.Analysis.TokenStream.knownMethodSupport">
            <deprecated> Remove this when old API is removed! 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Analysis.TokenStream.GetSupportedMethods(System.Type)">
            <deprecated> Remove this when old API is removed! 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Analysis.TokenStream.#ctor">
            <summary> A TokenStream using the default attribute factory.</summary>
        </member>
        <member name="M:Lucene.Net.Analysis.TokenStream.#ctor(Lucene.Net.Util.AttributeSource)">
            <summary> A TokenStream that uses the same attributes as the supplied one.</summary>
        </member>
        <member name="M:Lucene.Net.Analysis.TokenStream.#ctor(Lucene.Net.Util.AttributeSource.AttributeFactory)">
            <summary> A TokenStream using the supplied AttributeFactory for creating new {@link Attribute} instances.</summary>
        </member>
        <member name="M:Lucene.Net.Analysis.TokenStream.InitTokenWrapper(Lucene.Net.Util.AttributeSource)">
            <deprecated> Remove this when old API is removed! 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Analysis.TokenStream.Check">
            <deprecated> Remove this when old API is removed! 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Analysis.TokenStream.SetOnlyUseNewAPI(System.Boolean)">
            <summary> For extra performance you can globally enable the new
            {@link #IncrementToken} API using {@link Attribute}s. There will be a
            small, but in most cases negligible performance increase by enabling this,
            but it only works if <b>all</b> <code>TokenStream</code>s use the new API and
            implement {@link #IncrementToken}. This setting can only be enabled
            globally.
            <p/>
            This setting only affects <code>TokenStream</code>s instantiated after this
            call. All <code>TokenStream</code>s already created use the other setting.
            <p/>
            All core {@link Analyzer}s are compatible with this setting, if you have
            your own <code>TokenStream</code>s that are also compatible, you should enable
            this.
            <p/>
            When enabled, tokenization may throw {@link UnsupportedOperationException}
            s, if the whole tokenizer chain is not compatible eg one of the
            <code>TokenStream</code>s does not implement the new <code>TokenStream</code> API.
            <p/>
            The default is <code>false</code>, so there is the fallback to the old API
            available.
            
            </summary>
            <deprecated> This setting will no longer be needed in Lucene 3.0 as the old
            API will be removed.
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Analysis.TokenStream.GetOnlyUseNewAPI">
            <summary> Returns if only the new API is used.
            
            </summary>
            <seealso cref="!:setOnlyUseNewAPI">
            </seealso>
            <deprecated> This setting will no longer be needed in Lucene 3.0 as
            the old API will be removed.
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Analysis.TokenStream.IncrementToken">
            <summary> Consumers (i.e., {@link IndexWriter}) use this method to advance the stream to
            the next token. Implementing classes must implement this method and update
            the appropriate {@link AttributeImpl}s with the attributes of the next
            token.
            
            The producer must make no assumptions about the attributes after the
            method has been returned: the caller may arbitrarily change it. If the
            producer needs to preserve the state for subsequent calls, it can use
            {@link #captureState} to create a copy of the current attribute state.
            
            This method is called for every token of a document, so an efficient
            implementation is crucial for good performance. To avoid calls to
            {@link #AddAttribute(Class)} and {@link #GetAttribute(Class)} or downcasts,
            references to all {@link AttributeImpl}s that this stream uses should be
            retrieved during instantiation.
            
            To ensure that filters and consumers know which attributes are available,
            the attributes must be added during instantiation. Filters and consumers
            are not required to check for availability of attributes in
            {@link #IncrementToken()}.
            
            </summary>
            <returns> false for end of stream; true otherwise
            
            Note that this method will be defined abstract in Lucene
            3.0.
            </returns>
        </member>
        <member name="M:Lucene.Net.Analysis.TokenStream.End">
            <summary> This method is called by the consumer after the last token has been
            consumed, after {@link #IncrementToken()} returned <code>false</code>
            (using the new <code>TokenStream</code> API). Streams implementing the old API
            should upgrade to use this feature.
            <p/>
            This method can be used to perform any end-of-stream operations, such as
            setting the final offset of a stream. The final offset of a stream might
            differ from the offset of the last token eg in case one or more whitespaces
            followed after the last token, but a {@link WhitespaceTokenizer} was used.
            
            </summary>
            <throws>  IOException </throws>
        </member>
        <member name="M:Lucene.Net.Analysis.TokenStream.Next(Lucene.Net.Analysis.Token)">
            <summary> Returns the next token in the stream, or null at EOS. When possible, the
            input Token should be used as the returned Token (this gives fastest
            tokenization performance), but this is not required and a new Token may be
            returned. Callers may re-use a single Token instance for successive calls
            to this method.
            
            This implicitly defines a "contract" between consumers (callers of this
            method) and producers (implementations of this method that are the source
            for tokens):
            <ul>
            <li>A consumer must fully consume the previously returned {@link Token}
            before calling this method again.</li>
            <li>A producer must call {@link Token#Clear()} before setting the fields in
            it and returning it</li>
            </ul>
            Also, the producer must make no assumptions about a {@link Token} after it
            has been returned: the caller may arbitrarily change it. If the producer
            needs to hold onto the {@link Token} for subsequent calls, it must clone()
            it before storing it. Note that a {@link TokenFilter} is considered a
            consumer.
            
            </summary>
            <param name="reusableToken">a {@link Token} that may or may not be used to return;
            this parameter should never be null (the callee is not required to
            check for null before using it, but it is a good idea to assert that
            it is not null.)
            </param>
            <returns> next {@link Token} in the stream or null if end-of-stream was hit
            </returns>
            <deprecated> The new {@link #IncrementToken()} and {@link AttributeSource}
            APIs should be used instead.
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Analysis.TokenStream.Next">
            <summary> Returns the next {@link Token} in the stream, or null at EOS.
            
            </summary>
            <deprecated> The returned Token is a "full private copy" (not re-used across
            calls to {@link #Next()}) but will be slower than calling
            {@link #Next(Token)} or using the new {@link #IncrementToken()}
            method with the new {@link AttributeSource} API.
            </deprecated>
        </member>
        <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. {@link #Reset()} is not needed for
            the standard indexing process. However, if the tokens of a
            <code>TokenStream</code> are intended to be consumed more than once, it is
            necessary to implement {@link #Reset()}. Note that if your TokenStream
            caches tokens and feeds them back again after a reset, it is imperative
            that you clone the tokens when you store them away (on the first pass) as
            well as when you return them (on future passes after {@link #Reset()}).
            </summary>
        </member>
        <member name="M:Lucene.Net.Analysis.TokenStream.Close">
            <summary>Releases resources associated with this stream. </summary>
        </member>
        <member name="T:Lucene.Net.Analysis.TokenStream.MethodSupport">
            <deprecated> Remove this when old API is removed! 
            </deprecated>
        </member>
        <member name="T:Lucene.Net.Analysis.TokenStream.TokenWrapperAttributeFactory">
            <deprecated> Remove this when old API is removed! 
            </deprecated>
        </member>
        <member name="F:Lucene.Net.Analysis.TokenFilter.input">
            <summary>The source of tokens for this filter. </summary>
        </member>
        <member name="M:Lucene.Net.Analysis.TokenFilter.#ctor(Lucene.Net.Analysis.TokenStream)">
            <summary>Construct a token stream filtering the given input. </summary>
        </member>
        <member name="M:Lucene.Net.Analysis.TokenFilter.End">
            <summary>Performs end-of-stream operations, if any, and calls then <code>end()</code> on the
            input TokenStream.<p/> 
            <b>NOTE:</b> Be sure to call <code>super.end()</code> first when overriding this method.
            </summary>
        </member>
        <member name="M:Lucene.Net.Analysis.TokenFilter.Close">
            <summary>Close the input TokenStream. </summary>
        </member>
        <member name="M:Lucene.Net.Analysis.TokenFilter.Reset">
            <summary>Reset the filter as well as the input TokenStream. </summary>
        </member>
        <member name="M:Lucene.Net.Analysis.StopFilter.#ctor(Lucene.Net.Analysis.TokenStream,System.String[])">
            <summary> Construct a token stream filtering the given input.</summary>
            <deprecated> Use {@link #StopFilter(boolean, TokenStream, String[])} instead
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Analysis.StopFilter.#ctor(System.Boolean,Lucene.Net.Analysis.TokenStream,System.String[])">
            <summary> Construct a token stream filtering the given input.</summary>
            <param name="enablePositionIncrements">true if token positions should record the removed stop words
            </param>
            <param name="input">input TokenStream
            </param>
            <param name="stopWords">array of stop words
            </param>
            <deprecated> Use {@link #StopFilter(boolean, TokenStream, Set)} instead.
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Analysis.StopFilter.#ctor(Lucene.Net.Analysis.TokenStream,System.String[],System.Boolean)">
            <summary> Constructs a filter which removes words from the input
            TokenStream that are named in the array of words.
            </summary>
            <deprecated> Use {@link #StopFilter(boolean, TokenStream, String[], boolean)} instead
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Analysis.StopFilter.#ctor(System.Boolean,Lucene.Net.Analysis.TokenStream,System.String[],System.Boolean)">
            <summary> Constructs a filter which removes words from the input
            TokenStream that are named in the array of words.
            </summary>
            <param name="enablePositionIncrements">true if token positions should record the removed stop words
            </param>
            <param name="in">input TokenStream
            </param>
            <param name="stopWords">array of stop words
            </param>
            <param name="ignoreCase">true if case is ignored
            </param>
            <deprecated> Use {@link #StopFilter(boolean, TokenStream, Set, boolean)} instead.
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Analysis.StopFilter.#ctor(Lucene.Net.Analysis.TokenStream,System.Collections.Hashtable,System.Boolean)">
            <summary> Construct a token stream filtering the given input.
            If <code>stopWords</code> is an instance of {@link CharArraySet} (true if
            <code>makeStopSet()</code> was used to construct the set) it will be directly used
            and <code>ignoreCase</code> will be ignored since <code>CharArraySet</code>
            directly controls case sensitivity.
            <p/>
            If <code>stopWords</code> is not an instance of {@link CharArraySet},
            a new CharArraySet will be constructed and <code>ignoreCase</code> will be
            used to specify the case sensitivity of that set.
            
            </summary>
            <param name="input">
            </param>
            <param name="stopWords">The set of Stop Words.
            </param>
            <param name="ignoreCase">-Ignore case when stopping.
            </param>
            <deprecated> Use {@link #StopFilter(boolean, TokenStream, Set, boolean)} instead
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Analysis.StopFilter.#ctor(System.Boolean,Lucene.Net.Analysis.TokenStream,System.Collections.Hashtable,System.Boolean)">
            <summary> Construct a token stream filtering the given input.
            If <code>stopWords</code> is an instance of {@link CharArraySet} (true if
            <code>makeStopSet()</code> was used to construct the set) it will be directly used
            and <code>ignoreCase</code> will be ignored since <code>CharArraySet</code>
            directly controls case sensitivity.
            <p/>
            If <code>stopWords</code> is not an instance of {@link CharArraySet},
            a new CharArraySet will be constructed and <code>ignoreCase</code> will be
            used to specify the case sensitivity of that set.
            
            </summary>
            <param name="enablePositionIncrements">true if token positions should record the removed stop words
            </param>
            <param name="input">Input TokenStream
            </param>
            <param name="stopWords">The set of Stop Words.
            </param>
            <param name="ignoreCase">-Ignore case when stopping.
            </param>
        </member>
        <member name="M:Lucene.Net.Analysis.StopFilter.#ctor(Lucene.Net.Analysis.TokenStream,System.Collections.Hashtable)">
            <summary> Constructs a filter which removes words from the input
            TokenStream that are named in the Set.
            
            </summary>
            <seealso cref="!:MakeStopSet(java.lang.String[])">
            </seealso>
            <deprecated> Use {@link #StopFilter(boolean, TokenStream, Set)} instead
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Analysis.StopFilter.#ctor(System.Boolean,Lucene.Net.Analysis.TokenStream,System.Collections.Hashtable)">
            <summary> Constructs a filter which removes words from the input
            TokenStream that are named in the Set.
            
            </summary>
            <param name="enablePositionIncrements">true if token positions should record the removed stop words
            </param>
            <param name="in">Input stream
            </param>
            <param name="stopWords">The set of Stop Words.
            </param>
            <seealso cref="!:MakeStopSet(java.lang.String[])">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Analysis.StopFilter.MakeStopSet(System.String[])">
            <summary> Builds a Set from an array of stop words,
            appropriate for passing into the StopFilter constructor.
            This permits this stopWords construction to be cached once when
            an Analyzer is constructed.
            
            </summary>
            <seealso cref="!:MakeStopSet(java.lang.String[], boolean)"> passing false to ignoreCase
            </seealso>
        </member>
        <member name="M:Lucene.Net.Analysis.StopFilter.MakeStopSet(System.Collections.IList)">
            <summary> Builds a Set from an array of stop words,
            appropriate for passing into the StopFilter constructor.
            This permits this stopWords construction to be cached once when
            an Analyzer is constructed.
            
            </summary>
            <seealso cref="!:MakeStopSet(java.lang.String[], boolean)"> passing false to ignoreCase
            </seealso>
        </member>
        <member name="M:Lucene.Net.Analysis.StopFilter.MakeStopSet(System.String[],System.Boolean)">
            <summary> </summary>
            <param name="stopWords">An array of stopwords
            </param>
            <param name="ignoreCase">If true, all words are lower cased first.  
            </param>
            <returns> a Set containing the words
            </returns>
        </member>
        <member name="M:Lucene.Net.Analysis.StopFilter.MakeStopSet(System.Collections.IList,System.Boolean)">
            <summary> </summary>
            <param name="stopWords">A List of Strings representing the stopwords
            </param>
            <param name="ignoreCase">if true, all words are lower cased first
            </param>
            <returns> A Set containing the words
            </returns>
        </member>
        <member name="M:Lucene.Net.Analysis.StopFilter.IncrementToken">
            <summary> Returns the next input Token whose term() is not a stop word.</summary>
        </member>
        <member name="M:Lucene.Net.Analysis.StopFilter.GetEnablePositionIncrementsDefault">
            <seealso cref="M:Lucene.Net.Analysis.StopFilter.SetEnablePositionIncrementsDefault(System.Boolean)">
            </seealso>
            <deprecated> Please specify this when you create the StopFilter
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Analysis.StopFilter.GetEnablePositionIncrementsVersionDefault(Lucene.Net.Util.Version)">
            <summary> Returns version-dependent default for enablePositionIncrements. Analyzers
            that embed StopFilter use this method when creating the StopFilter. Prior
            to 2.9, this returns {@link #getEnablePositionIncrementsDefault}. On 2.9
            or later, it returns true.
            </summary>
        </member>
        <member name="M:Lucene.Net.Analysis.StopFilter.SetEnablePositionIncrementsDefault(System.Boolean)">
            <summary> Set the default position increments behavior of every StopFilter created
            from now on.
            <p/>
            Note: behavior of a single StopFilter instance can be modified with
            {@link #SetEnablePositionIncrements(boolean)}. This static method allows
            control over behavior of classes using StopFilters internally, for
            example {@link Lucene.Net.Analysis.Standard.StandardAnalyzer
            StandardAnalyzer} if used with the no-arg ctor.
            <p/>
            Default : false.
            
            </summary>
            <seealso cref="!:setEnablePositionIncrements(bool)">
            </seealso>
            <deprecated> Please specify this when you create the StopFilter
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Analysis.StopFilter.GetEnablePositionIncrements">
            <seealso cref="M:Lucene.Net.Analysis.StopFilter.SetEnablePositionIncrements(System.Boolean)">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Analysis.StopFilter.SetEnablePositionIncrements(System.Boolean)">
            <summary> If <code>true</code>, this StopFilter will preserve
            positions of the incoming tokens (ie, accumulate and
            set position increments of the removed stop tokens).
            Generally, <code>true</code> is best as it does not
            lose information (positions of the original tokens)
            during indexing.
            
            <p/> When set, when a token is stopped
            (omitted), the position increment of the following
            token is incremented.
            
            <p/> <b>NOTE</b>: be sure to also
            set {@link QueryParser#setEnablePositionIncrements} if
            you use QueryParser to create queries.
            </summary>
        </member>
        <member name="T:Lucene.Net.Analysis.Standard.StandardTokenizerImpl">
            <summary> This class is a scanner generated by 
            <a href="http://www.jflex.de/">JFlex</a> 1.4.1
            on 9/4/08 6:49 PM from the specification file
            <tt>/tango/mike/src/lucene.standarddigit/src/java/org/apache/lucene/analysis/standard/StandardTokenizerImpl.jflex</tt>
            </summary>
        </member>
        <member name="F:Lucene.Net.Analysis.Standard.StandardTokenizerImpl.YYEOF">
            <summary>This character denotes the end of file </summary>
        </member>
        <member name="F:Lucene.Net.Analysis.Standard.StandardTokenizerImpl.ZZ_BUFFERSIZE">
            <summary>initial size of the lookahead buffer </summary>
        </member>
        <member name="F:Lucene.Net.Analysis.Standard.StandardTokenizerImpl.YYINITIAL">
            <summary>lexical states </summary>
        </member>
        <member name="F:Lucene.Net.Analysis.Standard.StandardTokenizerImpl.ZZ_CMAP_PACKED">
            <summary> Translates characters to character classes</summary>
        </member>
        <member name="F:Lucene.Net.Analysis.Standard.StandardTokenizerImpl.ZZ_CMAP">
            <summary> Translates characters to character classes</summary>
        </member>
        <member name="F:Lucene.Net.Analysis.Standard.StandardTokenizerImpl.ZZ_ACTION">
            <summary> Translates DFA states to action switch labels.</summary>
        </member>
        <member name="F:Lucene.Net.Analysis.Standard.StandardTokenizerImpl.ZZ_ROWMAP">
            <summary> Translates a state to a row index in the transition table</summary>
        </member>
        <member name="F:Lucene.Net.Analysis.Standard.StandardTokenizerImpl.ZZ_TRANS">
            <summary> The transition table of the DFA</summary>
        </member>
        <member name="F:Lucene.Net.Analysis.Standard.StandardTokenizerImpl.ZZ_ATTRIBUTE">
            <summary> ZZ_ATTRIBUTE[aState] contains the attributes of state <code>aState</code></summary>
        </member>
        <member name="F:Lucene.Net.Analysis.Standard.StandardTokenizerImpl.zzReader">
            <summary>the input device </summary>
        </member>
        <member name="F:Lucene.Net.Analysis.Standard.StandardTokenizerImpl.zzState">
            <summary>the current state of the DFA </summary>
        </member>
        <member name="F:Lucene.Net.Analysis.Standard.StandardTokenizerImpl.zzLexicalState">
            <summary>the current lexical state </summary>
        </member>
        <member name="F:Lucene.Net.Analysis.Standard.StandardTokenizerImpl.zzBuffer">
            <summary>this buffer contains the current text to be matched and is
            the source of the yytext() string 
            </summary>
        </member>
        <member name="F:Lucene.Net.Analysis.Standard.StandardTokenizerImpl.zzMarkedPos">
            <summary>the textposition at the last accepting state </summary>
        </member>
        <member name="F:Lucene.Net.Analysis.Standard.StandardTokenizerImpl.zzPushbackPos">
            <summary>the textposition at the last state to be included in yytext </summary>
        </member>
        <member name="F:Lucene.Net.Analysis.Standard.StandardTokenizerImpl.zzCurrentPos">
            <summary>the current text position in the buffer </summary>
        </member>
        <member name="F:Lucene.Net.Analysis.Standard.StandardTokenizerImpl.zzStartRead">
            <summary>startRead marks the beginning of the yytext() string in the buffer </summary>
        </member>
        <member name="F:Lucene.Net.Analysis.Standard.StandardTokenizerImpl.zzEndRead">
            <summary>endRead marks the last character in the buffer, that has been read
            from input 
            </summary>
        </member>
        <member name="F:Lucene.Net.Analysis.Standard.StandardTokenizerImpl.yyline">
            <summary>number of newlines encountered up to the start of the matched text </summary>
        </member>
        <member name="F:Lucene.Net.Analysis.Standard.StandardTokenizerImpl.yychar">
            <summary>the number of characters up to the start of the matched text </summary>
        </member>
        <member name="F:Lucene.Net.Analysis.Standard.StandardTokenizerImpl.yycolumn">
            <summary> the number of characters from the last newline up to the start of the 
            matched text
            </summary>
        </member>
        <member name="F:Lucene.Net.Analysis.Standard.StandardTokenizerImpl.zzAtBOL">
            <summary> zzAtBOL == true &lt;=&gt; the scanner is currently at the beginning of a line</summary>
        </member>
        <member name="F:Lucene.Net.Analysis.Standard.StandardTokenizerImpl.zzAtEOF">
            <summary>zzAtEOF == true &lt;=&gt; the scanner is at the EOF </summary>
        </member>
        <member name="F:Lucene.Net.Analysis.Standard.StandardTokenizerImpl.ACRONYM_DEP">
            <deprecated> this solves a bug where HOSTs that end with '.' are identified
            as ACRONYMs. It is deprecated and will be removed in the next
            release.
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Analysis.Standard.StandardTokenizerImpl.Reset(System.IO.TextReader)">
            Resets the Tokenizer to a new Reader.
        </member>
        <member name="M:Lucene.Net.Analysis.Standard.StandardTokenizerImpl.GetText(Lucene.Net.Analysis.Token)">
            <summary> Fills Lucene token with the current token text.</summary>
        </member>
        <member name="M:Lucene.Net.Analysis.Standard.StandardTokenizerImpl.GetText(Lucene.Net.Analysis.Tokenattributes.TermAttribute)">
            <summary> Fills TermAttribute with the current token text.</summary>
        </member>
        <member name="M:Lucene.Net.Analysis.Standard.StandardTokenizerImpl.#ctor(System.IO.TextReader)">
            <summary> Creates a new scanner
            There is also a java.io.InputStream version of this constructor.
            
            </summary>
            <param name="in"> the java.io.Reader to read input from.
            </param>
        </member>
        <member name="M:Lucene.Net.Analysis.Standard.StandardTokenizerImpl.#ctor(System.IO.Stream)">
            <summary> Creates a new scanner.
            There is also java.io.Reader version of this constructor.
            
            </summary>
            <param name="in"> the java.io.Inputstream to read input from.
            </param>
        </member>
        <member name="M:Lucene.Net.Analysis.Standard.StandardTokenizerImpl.ZzUnpackCMap(System.String)">
            <summary> Unpacks the compressed character translation table.
            
            </summary>
            <param name="packed">  the packed character translation table
            </param>
            <returns>         the unpacked character translation table
            </returns>
        </member>
        <member name="M:Lucene.Net.Analysis.Standard.StandardTokenizerImpl.ZzRefill">
            <summary> Refills the input buffer.
            
            </summary>
            <returns>      <code>false</code>, iff there was new input.
            
            </returns>
            <exception cref="!:java.io.IOException"> if any I/O-Error occurs
            </exception>
        </member>
        <member name="M:Lucene.Net.Analysis.Standard.StandardTokenizerImpl.Yyclose">
            <summary> Closes the input stream.</summary>
        </member>
        <member name="M:Lucene.Net.Analysis.Standard.StandardTokenizerImpl.Yyreset(System.IO.TextReader)">
            <summary> Resets the scanner to read from a new input stream.
            Does not close the old reader.
            
            All internal variables are reset, the old input stream 
            <b>cannot</b> be reused (internal buffer is discarded and lost).
            Lexical state is set to <tt>ZZ_INITIAL</tt>.
            
            </summary>
            <param name="reader">  the new input stream 
            </param>
        </member>
        <member name="M:Lucene.Net.Analysis.Standard.StandardTokenizerImpl.Yystate">
            <summary> Returns the current lexical state.</summary>
        </member>
        <member name="M:Lucene.Net.Analysis.Standard.StandardTokenizerImpl.Yybegin(System.Int32)">
            <summary> Enters a new lexical state
            
            </summary>
            <param name="newState">the new lexical state
            </param>
        </member>
        <member name="M:Lucene.Net.Analysis.Standard.StandardTokenizerImpl.Yytext">
            <summary> Returns the text matched by the current regular expression.</summary>
        </member>
        <member name="M:Lucene.Net.Analysis.Standard.StandardTokenizerImpl.Yycharat(System.Int32)">
            <summary> Returns the character at position <tt>pos</tt> from the 
            matched text. 
            
            It is equivalent to yytext().charAt(pos), but faster
            
            </summary>
            <param name="pos">the position of the character to fetch. 
            A value from 0 to yylength()-1.
            
            </param>
            <returns> the character at position pos
            </returns>
        </member>
        <member name="M:Lucene.Net.Analysis.Standard.StandardTokenizerImpl.Yylength">
            <summary> Returns the length of the matched text region.</summary>
        </member>
        <member name="M:Lucene.Net.Analysis.Standard.StandardTokenizerImpl.ZzScanError(System.Int32)">
            <summary> Reports an error that occured while scanning.
            
            In a wellformed scanner (no or only correct usage of 
            yypushback(int) and a match-all fallback rule) this method 
            will only be called with things that "Can't Possibly Happen".
            If this method is called, something is seriously wrong
            (e.g. a JFlex bug producing a faulty scanner etc.).
            
            Usual syntax/scanner level error handling should be done
            in error fallback rules.
            
            </summary>
            <param name="errorCode"> the code of the errormessage to display
            </param>
        </member>
        <member name="M:Lucene.Net.Analysis.Standard.StandardTokenizerImpl.Yypushback(System.Int32)">
            <summary> Pushes the specified amount of characters back into the input stream.
            
            They will be read again by then next call of the scanning method
            
            </summary>
            <param name="number"> the number of characters to be read again.
            This number must not be greater than yylength()!
            </param>
        </member>
        <member name="M:Lucene.Net.Analysis.Standard.StandardTokenizerImpl.GetNextToken">
            <summary> Resumes scanning until the next regular expression is matched,
            the end of input is encountered or an I/O-Error occurs.
            
            </summary>
            <returns>      the next token
            </returns>
            <exception cref="!:java.io.IOException"> if any I/O-Error occurs
            </exception>
        </member>
        <member name="T:Lucene.Net.Analysis.Standard.StandardAnalyzer">
            <summary> Filters {@link StandardTokenizer} with {@link StandardFilter},
            {@link LowerCaseFilter} and {@link StopFilter}, using a list of English stop
            words.
            
            <a name="version"/>
            <p/>
            You must specify the required {@link Version} compatibility when creating
            StandardAnalyzer:
            <ul>
            <li>As of 2.9, StopFilter preserves position increments</li>
            <li>As of 2.4, Tokens incorrectly identified as acronyms are corrected (see
            <a href="https://issues.apache.org/jira/browse/LUCENE-1068">LUCENE-1608</a></li>
            </ul>
            
            </summary>
            <version>  $Id: StandardAnalyzer.java 829134 2009-10-23 17:18:53Z mikemccand $
            </version>
        </member>
        <member name="T:Lucene.Net.Analysis.Analyzer">
            <summary>An Analyzer builds TokenStreams, which analyze text.  It thus represents a
            policy for extracting index terms from text.
            <p/>
            Typical implementations first build a Tokenizer, which breaks the stream of
            characters from the Reader into raw Tokens.  One or more TokenFilters may
            then be applied to the output of the Tokenizer.
            </summary>
        </member>
        <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.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.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.SetOverridesTokenStreamMethod(System.Type)">
            <deprecated> This is only present to preserve
            back-compat of classes that subclass a core analyzer
            and override tokenStream but not reusableTokenStream 
            </deprecated>
        </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="fieldName">Fieldable name being indexed.
            </param>
            <returns> position increment gap, added to the next token emitted from {@link #TokenStream(String,Reader)}
            </returns>
        </member>
        <member name="M:Lucene.Net.Analysis.Analyzer.GetOffsetGap(Lucene.Net.Documents.Fieldable)">
            <summary> Just like {@link #getPositionIncrementGap}, except for
            Token offsets instead.  By default this returns 1 for
            tokenized fields and, as if the fields were joined
            with an extra space character, and 0 for un-tokenized
            fields.  This method is only called if the field
            produced at least one token for indexing.
            
            </summary>
            <param name="field">the field just indexed
            </param>
            <returns> offset gap, added to the next token emitted from {@link #TokenStream(String,Reader)}
            </returns>
        </member>
        <member name="M:Lucene.Net.Analysis.Analyzer.Close">
            <summary>Frees persistent resources used by this Analyzer </summary>
        </member>
        <member name="F:Lucene.Net.Analysis.Standard.StandardAnalyzer.DEFAULT_MAX_TOKEN_LENGTH">
            <summary>Default maximum allowed token length </summary>
        </member>
        <member name="F:Lucene.Net.Analysis.Standard.StandardAnalyzer.replaceInvalidAcronym">
            <summary> Specifies whether deprecated acronyms should be replaced with HOST type.
            This is false by default to support backward compatibility.
            
            </summary>
            <deprecated> this should be removed in the next release (3.0).
            
            See https://issues.apache.org/jira/browse/LUCENE-1068
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Analysis.Standard.StandardAnalyzer.GetDefaultReplaceInvalidAcronym">
            <summary> </summary>
            <returns> true if new instances of StandardTokenizer will
            replace mischaracterized acronyms
            
            See https://issues.apache.org/jira/browse/LUCENE-1068
            </returns>
            <deprecated> This will be removed (hardwired to true) in 3.0
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Analysis.Standard.StandardAnalyzer.SetDefaultReplaceInvalidAcronym(System.Boolean)">
            <summary> </summary>
            <param name="replaceInvalidAcronym">Set to true to have new
            instances of StandardTokenizer replace mischaracterized
            acronyms by default.  Set to false to preserve the
            previous (before 2.4) buggy behavior.  Alternatively,
            set the system property
            Lucene.Net.Analysis.Standard.StandardAnalyzer.replaceInvalidAcronym
            to false.
            
            See https://issues.apache.org/jira/browse/LUCENE-1068
            </param>
            <deprecated> This will be removed (hardwired to true) in 3.0
            </deprecated>
        </member>
        <member name="F:Lucene.Net.Analysis.Standard.StandardAnalyzer.STOP_WORDS">
            <summary>An array containing some common English words that are usually not
            useful for searching. 
            </summary>
            <deprecated> Use {@link #STOP_WORDS_SET} instead 
            </deprecated>
        </member>
        <member name="F:Lucene.Net.Analysis.Standard.StandardAnalyzer.STOP_WORDS_SET">
            <summary>An unmodifiable set containing some common English words that are usually not
            useful for searching. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Analysis.Standard.StandardAnalyzer.#ctor">
            <summary>Builds an analyzer with the default stop words ({@link
            #STOP_WORDS_SET}).
            </summary>
            <deprecated> Use {@link #StandardAnalyzer(Version)} instead. 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Analysis.Standard.StandardAnalyzer.#ctor(Lucene.Net.Util.Version)">
            <summary>Builds an analyzer with the default stop words ({@link
            #STOP_WORDS}).
            </summary>
            <param name="matchVersion">Lucene version to match See {@link
            <a href="#version">above</a>}
            </param>
        </member>
        <member name="M:Lucene.Net.Analysis.Standard.StandardAnalyzer.#ctor(System.Collections.Hashtable)">
            <summary>Builds an analyzer with the given stop words.</summary>
            <deprecated> Use {@link #StandardAnalyzer(Version, Set)}
            instead 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Analysis.Standard.StandardAnalyzer.#ctor(Lucene.Net.Util.Version,System.Collections.Hashtable)">
            <summary>Builds an analyzer with the given stop words.</summary>
            <param name="matchVersion">Lucene version to match See {@link
            <a href="#version">above</a>}
            </param>
            <param name="stopWords">stop words 
            </param>
        </member>
        <member name="M:Lucene.Net.Analysis.Standard.StandardAnalyzer.#ctor(System.String[])">
            <summary>Builds an analyzer with the given stop words.</summary>
            <deprecated> Use {@link #StandardAnalyzer(Version, Set)} instead 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Analysis.Standard.StandardAnalyzer.#ctor(System.IO.FileInfo)">
            <summary>Builds an analyzer with the stop words from the given file.</summary>
            <seealso cref="!:WordlistLoader.GetWordSet(File)">
            </seealso>
            <deprecated> Use {@link #StandardAnalyzer(Version, File)}
            instead
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Analysis.Standard.StandardAnalyzer.#ctor(Lucene.Net.Util.Version,System.IO.FileInfo)">
            <summary>Builds an analyzer with the stop words from the given file.</summary>
            <seealso cref="!:WordlistLoader.GetWordSet(File)">
            </seealso>
            <param name="matchVersion">Lucene version to match See {@link
            <a href="#version">above</a>}
            </param>
            <param name="stopwords">File to read stop words from 
            </param>
        </member>
        <member name="M:Lucene.Net.Analysis.Standard.StandardAnalyzer.#ctor(System.IO.TextReader)">
            <summary>Builds an analyzer with the stop words from the given reader.</summary>
            <seealso cref="!:WordlistLoader.GetWordSet(Reader)">
            </seealso>
            <deprecated> Use {@link #StandardAnalyzer(Version, Reader)}
            instead
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Analysis.Standard.StandardAnalyzer.#ctor(Lucene.Net.Util.Version,System.IO.TextReader)">
            <summary>Builds an analyzer with the stop words from the given reader.</summary>
            <seealso cref="!:WordlistLoader.GetWordSet(Reader)">
            </seealso>
            <param name="matchVersion">Lucene version to match See {@link
            <a href="#version">above</a>}
            </param>
            <param name="stopwords">Reader to read stop words from 
            </param>
        </member>
        <member name="M:Lucene.Net.Analysis.Standard.StandardAnalyzer.#ctor(System.Boolean)">
            <summary> </summary>
            <param name="replaceInvalidAcronym">Set to true if this analyzer should replace mischaracterized acronyms in the StandardTokenizer
            
            See https://issues.apache.org/jira/browse/LUCENE-1068
            
            </param>
            <deprecated> Remove in 3.X and make true the only valid value
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Analysis.Standard.StandardAnalyzer.#ctor(System.IO.TextReader,System.Boolean)">
            <param name="stopwords">The stopwords to use
            </param>
            <param name="replaceInvalidAcronym">Set to true if this analyzer should replace mischaracterized acronyms in the StandardTokenizer
            
            See https://issues.apache.org/jira/browse/LUCENE-1068
            
            </param>
            <deprecated> Remove in 3.X and make true the only valid value
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Analysis.Standard.StandardAnalyzer.#ctor(System.IO.FileInfo,System.Boolean)">
            <param name="stopwords">The stopwords to use
            </param>
            <param name="replaceInvalidAcronym">Set to true if this analyzer should replace mischaracterized acronyms in the StandardTokenizer
            
            See https://issues.apache.org/jira/browse/LUCENE-1068
            
            </param>
            <deprecated> Remove in 3.X and make true the only valid value
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Analysis.Standard.StandardAnalyzer.#ctor(System.String[],System.Boolean)">
            <summary> </summary>
            <param name="stopwords">The stopwords to use
            </param>
            <param name="replaceInvalidAcronym">Set to true if this analyzer should replace mischaracterized acronyms in the StandardTokenizer
            
            See https://issues.apache.org/jira/browse/LUCENE-1068
            
            </param>
            <deprecated> Remove in 3.X and make true the only valid value
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Analysis.Standard.StandardAnalyzer.#ctor(System.Collections.Hashtable,System.Boolean)">
            <param name="stopwords">The stopwords to use
            </param>
            <param name="replaceInvalidAcronym">Set to true if this analyzer should replace mischaracterized acronyms in the StandardTokenizer
            
            See https://issues.apache.org/jira/browse/LUCENE-1068
            
            </param>
            <deprecated> Remove in 3.X and make true the only valid value
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Analysis.Standard.StandardAnalyzer.TokenStream(System.String,System.IO.TextReader)">
            <summary>Constructs a {@link StandardTokenizer} filtered by a {@link
            StandardFilter}, a {@link LowerCaseFilter} and a {@link StopFilter}. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Analysis.Standard.StandardAnalyzer.SetMaxTokenLength(System.Int32)">
            <summary> Set maximum allowed token length.  If a token is seen
            that exceeds this length then it is discarded.  This
            setting only takes effect the next time tokenStream or
            reusableTokenStream is called.
            </summary>
        </member>
        <member name="M:Lucene.Net.Analysis.Standard.StandardAnalyzer.GetMaxTokenLength">
            <seealso cref="!:setMaxTokenLength">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Analysis.Standard.StandardAnalyzer.ReusableTokenStream(System.String,System.IO.TextReader)">
            <deprecated> Use {@link #tokenStream} instead 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Analysis.Standard.StandardAnalyzer.IsReplaceInvalidAcronym">
            <summary> </summary>
            <returns> true if this Analyzer is replacing mischaracterized acronyms in the StandardTokenizer
            
            See https://issues.apache.org/jira/browse/LUCENE-1068
            </returns>
            <deprecated> This will be removed (hardwired to true) in 3.0
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Analysis.Standard.StandardAnalyzer.SetReplaceInvalidAcronym(System.Boolean)">
            <summary> </summary>
            <param name="replaceInvalidAcronym">Set to true if this Analyzer is replacing mischaracterized acronyms in the StandardTokenizer
            
            See https://issues.apache.org/jira/browse/LUCENE-1068
            </param>
            <deprecated> This will be removed (hardwired to true) in 3.0
            </deprecated>
        </member>
        <member name="T:Lucene.Net.Analysis.SimpleAnalyzer">
            <summary>An {@link Analyzer} that filters {@link LetterTokenizer} 
            with {@link LowerCaseFilter} 
            </summary>
        </member>
        <member name="T:Lucene.Net.Analysis.MappingCharFilter">
            <summary> Simplistic {@link CharFilter} that applies the mappings
            contained in a {@link NormalizeCharMap} to the character
            stream, and correcting the resulting changes to the
            offsets.
            </summary>
        </member>
        <member name="T:Lucene.Net.Analysis.BaseCharFilter">
            <summary>
            * Base utility class for implementing a {@link CharFilter}.
            * You subclass this, and then record mappings by calling
            * {@link #addOffCorrectMap}, and then invoke the correct
            * method to correct an offset.
            </summary>
        </member>
        <member name="T:Lucene.Net.Analysis.CharFilter">
            <summary> Subclasses of CharFilter can be chained to filter CharStream.
            They can be used as {@link java.io.Reader} with additional offset
            correction. {@link Tokenizer}s will automatically use {@link #CorrectOffset}
            if a CharFilter/CharStream subclass is used.
            
            </summary>
            <version>  $Id$
            
            </version>
        </member>
        <member name="T:Lucene.Net.Analysis.CharStream">
            <summary> CharStream adds {@link #CorrectOffset}
            functionality over {@link Reader}.  All Tokenizers accept a
            CharStream instead of {@link Reader} as input, which enables
            arbitrary character based filtering before tokenization. 
            The {@link #CorrectOffset} method fixed offsets to account for
            removal or insertion of characters, so that the offsets
            reported in the tokens match the character offsets of the
            original Reader.
            </summary>
        </member>
        <member name="M:Lucene.Net.Analysis.CharStream.CorrectOffset(System.Int32)">
            <summary> Called by CharFilter(s) and Tokenizer to correct token offset.
            
            </summary>
            <param name="currentOff">offset as seen in the output
            </param>
            <returns> corrected offset based on the input
            </returns>
        </member>
        <member name="M:Lucene.Net.Analysis.CharFilter.Correct(System.Int32)">
            <summary> Subclass may want to override to correct the current offset.
            
            </summary>
            <param name="currentOff">current offset
            </param>
            <returns> corrected offset
            </returns>
        </member>
        <member name="M:Lucene.Net.Analysis.CharFilter.CorrectOffset(System.Int32)">
            <summary> Chains the corrected offset through the input
            CharFilter.
            </summary>
        </member>
        <member name="M:Lucene.Net.Analysis.BaseCharFilter.Correct(System.Int32)">
            Retrieve the corrected offset. 
        </member>
        <member name="M:Lucene.Net.Analysis.MappingCharFilter.#ctor(Lucene.Net.Analysis.NormalizeCharMap,Lucene.Net.Analysis.CharStream)">
            Default constructor that takes a {@link CharStream}.
        </member>
        <member name="M:Lucene.Net.Analysis.MappingCharFilter.#ctor(Lucene.Net.Analysis.NormalizeCharMap,System.IO.TextReader)">
            Easy-use constructor that takes a {@link Reader}.
        </member>
        <member name="T:Lucene.Net.Analysis.CharReader">
            <summary> CharReader is a Reader wrapper. It reads chars from
            Reader and outputs {@link CharStream}, defining an
            identify function {@link #CorrectOffset} method that
            simply returns the provided offset.
            </summary>
        </member>
        <member name="T:Lucene.Net.Util.SortedVIntList">
            <summary> Stores and iterate on sorted integers in compressed form in RAM. <br/>
            The code for compressing the differences between ascending integers was
            borrowed from {@link Lucene.Net.Store.IndexInput} and
            {@link Lucene.Net.Store.IndexOutput}.
            <p/>
            <b>NOTE:</b> this class assumes the stored integers are doc Ids (hence why it
            extends {@link DocIdSet}). Therefore its {@link #Iterator()} assumes {@link
            DocIdSetIterator#NO_MORE_DOCS} can be used as sentinel. If you intent to use
            this value, then make sure it's not used during search flow.
            </summary>
        </member>
        <member name="T:Lucene.Net.Search.DocIdSet">
            <summary> A DocIdSet contains a set of doc ids. Implementing classes must
            only implement {@link #iterator} to provide access to the set. 
            </summary>
        </member>
        <member name="F:Lucene.Net.Search.DocIdSet.EMPTY_DOCIDSET">
            <summary>An empty {@code DocIdSet} instance for easy use, e.g. in Filters that hit no documents. </summary>
        </member>
        <member name="M:Lucene.Net.Search.DocIdSet.Iterator">
            <summary>Provides a {@link DocIdSetIterator} to access the set.
            This implementation can return <code>null</code> or
            <code>{@linkplain #EMPTY_DOCIDSET}.iterator()</code> if there
            are no docs that match. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.DocIdSet.IsCacheable">
            <summary>This method is a hint for {@link CachingWrapperFilter}, if this <code>DocIdSet</code>
            should be cached without copying it into a BitSet. The default is to return
            <code>false</code>. If you have an own <code>DocIdSet</code> implementation
            that does its iteration very effective and fast without doing disk I/O,
            override this method and return true.
            </summary>
        </member>
        <member name="F:Lucene.Net.Util.SortedVIntList.BITS2VINTLIST_SIZE">
            <summary>When a BitSet has fewer than 1 in BITS2VINTLIST_SIZE bits set,
            a SortedVIntList representing the index numbers of the set bits
            will be smaller than that BitSet.
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.SortedVIntList.#ctor(System.Int32[])">
            <summary>  Create a SortedVIntList from all elements of an array of integers.
            
            </summary>
            <param name="sortedInts"> A sorted array of non negative integers.
            </param>
        </member>
        <member name="M:Lucene.Net.Util.SortedVIntList.#ctor(System.Int32[],System.Int32)">
            <summary> Create a SortedVIntList from an array of integers.</summary>
            <param name="sortedInts"> An array of sorted non negative integers.
            </param>
            <param name="inputSize">  The number of integers to be used from the array.
            </param>
        </member>
        <member name="M:Lucene.Net.Util.SortedVIntList.#ctor(System.Collections.BitArray)">
            <summary> Create a SortedVIntList from a BitSet.</summary>
            <param name="bits"> A bit set representing a set of integers.
            </param>
        </member>
        <member name="M:Lucene.Net.Util.SortedVIntList.#ctor(Lucene.Net.Util.OpenBitSet)">
            <summary> Create a SortedVIntList from an OpenBitSet.</summary>
            <param name="bits"> A bit set representing a set of integers.
            </param>
        </member>
        <member name="M:Lucene.Net.Util.SortedVIntList.#ctor(Lucene.Net.Search.DocIdSetIterator)">
            <summary> Create a SortedVIntList.</summary>
            <param name="docIdSetIterator"> An iterator providing document numbers as a set of integers.
            This DocIdSetIterator is iterated completely when this constructor
            is called and it must provide the integers in non
            decreasing order.
            </param>
        </member>
        <member name="M:Lucene.Net.Util.SortedVIntList.Size">
            <returns>    The total number of sorted integers.
            </returns>
        </member>
        <member name="M:Lucene.Net.Util.SortedVIntList.GetByteSize">
            <returns> The size of the byte array storing the compressed sorted integers.
            </returns>
        </member>
        <member name="M:Lucene.Net.Util.SortedVIntList.IsCacheable">
            <summary>This DocIdSet implementation is cacheable. </summary>
        </member>
        <member name="M:Lucene.Net.Util.SortedVIntList.Iterator">
            <returns>    An iterator over the sorted integers.
            </returns>
        </member>
        <member name="M:Lucene.Net.Util.SortedVIntList.AnonymousClassDocIdSetIterator.Doc">
            <deprecated> use {@link #DocID()} instead. 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Util.SortedVIntList.AnonymousClassDocIdSetIterator.Next">
            <deprecated> use {@link #NextDoc()} instead. 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Util.SortedVIntList.AnonymousClassDocIdSetIterator.SkipTo(System.Int32)">
            <deprecated> use {@link #Advance(int)} instead. 
            </deprecated>
        </member>
        <member name="T:Lucene.Net.Util.ScorerDocQueue">
            <summary>A ScorerDocQueue maintains a partial ordering of its Scorers such that the
            least Scorer can always be found in constant time.  Put()'s and pop()'s
            require log(size) time. The ordering is by Scorer.doc().
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.ScorerDocQueue.#ctor(System.Int32)">
            <summary>Create a ScorerDocQueue with a maximum size. </summary>
        </member>
        <member name="M:Lucene.Net.Util.ScorerDocQueue.Put(Lucene.Net.Search.Scorer)">
            <summary> Adds a Scorer to a ScorerDocQueue in log(size) time.
            If one tries to add more Scorers than maxSize
            a RuntimeException (ArrayIndexOutOfBound) is thrown.
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.ScorerDocQueue.Insert(Lucene.Net.Search.Scorer)">
            <summary> Adds a Scorer to the ScorerDocQueue in log(size) time if either
            the ScorerDocQueue is not full, or not lessThan(scorer, top()).
            </summary>
            <param name="scorer">
            </param>
            <returns> true if scorer is added, false otherwise.
            </returns>
        </member>
        <member name="M:Lucene.Net.Util.ScorerDocQueue.Top">
            <summary>Returns the least Scorer of the ScorerDocQueue in constant time.
            Should not be used when the queue is empty.
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.ScorerDocQueue.TopDoc">
            <summary>Returns document number of the least Scorer of the ScorerDocQueue
            in constant time.
            Should not be used when the queue is empty.
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.ScorerDocQueue.Pop">
            <summary>Removes and returns the least scorer of the ScorerDocQueue in log(size)
            time.
            Should not be used when the queue is empty.
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.ScorerDocQueue.PopNoResult">
            <summary>Removes the least scorer of the ScorerDocQueue in log(size) time.
            Should not be used when the queue is empty.
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.ScorerDocQueue.AdjustTop">
            <summary>Should be called when the scorer at top changes doc() value.
            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>
        </member>
        <member name="M:Lucene.Net.Util.ScorerDocQueue.Size">
            <summary>Returns the number of scorers currently stored in the ScorerDocQueue. </summary>
        </member>
        <member name="M:Lucene.Net.Util.ScorerDocQueue.Clear">
            <summary>Removes all entries from the ScorerDocQueue. </summary>
        </member>
        <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>
            
            Test system: Pentium 4, Sun Java 1.5_06 -server -Xbatch -Xmx64M
            <br/>BitSet size = 1,000,000
            <br/>Results are java.util.BitSet time divided by OpenBitSet time.
            <table border="1">
            <tr>
            <th></th> <th>cardinality</th> <th>intersect_count</th> <th>union</th> <th>nextSetBit</th> <th>get</th> <th>iterator</th>
            </tr>
            <tr>
            <th>50% full</th> <td>3.36</td> <td>3.96</td> <td>1.44</td> <td>1.46</td> <td>1.99</td> <td>1.58</td>
            </tr>
            <tr>
            <th>1% full</th> <td>3.31</td> <td>3.90</td> <td>&#160;</td> <td>1.04</td> <td>&#160;</td> <td>0.99</td>
            </tr>
            </table>
            <br/>
            Test system: AMD Opteron, 64 bit linux, Sun Java 1.5_06 -server -Xbatch -Xmx64M
            <br/>BitSet size = 1,000,000
            <br/>Results are java.util.BitSet time divided by OpenBitSet time.
            <table border="1">
            <tr>
            <th></th> <th>cardinality</th> <th>intersect_count</th> <th>union</th> <th>nextSetBit</th> <th>get</th> <th>iterator</th>
            </tr>
            <tr>
            <th>50% full</th> <td>2.50</td> <td>3.50</td> <td>1.00</td> <td>1.03</td> <td>1.12</td> <td>1.25</td>
            </tr>
            <tr>
            <th>1% full</th> <td>2.51</td> <td>3.49</td> <td>&#160;</td> <td>1.00</td> <td>&#160;</td> <td>1.02</td>
            </tr>
            </table>
            </summary>
            <version>  $Id$
            </version>
        </member>
        <member name="M:Lucene.Net.Util.OpenBitSet.#ctor(System.Int64)">
            <summary>Constructs an OpenBitSet large enough to hold numBits.
            
            </summary>
            <param name="numBits">
            </param>
        </member>
        <member name="M:Lucene.Net.Util.OpenBitSet.#ctor(System.Int64[],System.Int32)">
            <summary>Constructs an OpenBitSet from an existing long[].
            <br/>
            The first 64 bits are in long[0],
            with bit index 0 at the least significant bit, and bit index 63 at the most significant.
            Given a bit index,
            the word containing it is long[index/64], and it is at bit number index%64 within that word.
            <p/>
            numWords are the number of elements in the array that contain
            set bits (non-zero longs).
            numWords should be &lt;= bits.length, and
            any existing words in the array at position &gt;= numWords should be zero.
            
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.OpenBitSet.IsCacheable">
            <summary>This DocIdSet implementation is cacheable. </summary>
        </member>
        <member name="M:Lucene.Net.Util.OpenBitSet.Capacity">
            <summary>Returns the current capacity in bits (1 greater than the index of the last bit) </summary>
        </member>
        <member name="M:Lucene.Net.Util.OpenBitSet.Size">
            <summary> Returns the current capacity of this set.  Included for
            compatibility.  This is *not* equal to {@link #cardinality}
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.OpenBitSet.IsEmpty">
            <summary>Returns true if there are no set bits </summary>
        </member>
        <member name="M:Lucene.Net.Util.OpenBitSet.GetBits">
            <summary>Expert: returns the long[] storing the bits </summary>
        </member>
        <member name="M:Lucene.Net.Util.OpenBitSet.SetBits(System.Int64[])">
            <summary>Expert: sets a new long[] to use as the bit storage </summary>
        </member>
        <member name="M:Lucene.Net.Util.OpenBitSet.GetNumWords">
            <summary>Expert: gets the number of longs in the array that are in use </summary>
        </member>
        <member name="M:Lucene.Net.Util.OpenBitSet.SetNumWords(System.Int32)">
            <summary>Expert: sets the number of longs in the array that are in use </summary>
        </member>
        <member name="M:Lucene.Net.Util.OpenBitSet.Get(System.Int32)">
            <summary>Returns true or false for the specified bit index. </summary>
        </member>
        <member name="M:Lucene.Net.Util.OpenBitSet.FastGet(System.Int32)">
            <summary>Returns true or false for the specified bit index.
            The index should be less than the OpenBitSet size
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.OpenBitSet.Get(System.Int64)">
            <summary>Returns true or false for the specified bit index</summary>
        </member>
        <member name="M:Lucene.Net.Util.OpenBitSet.FastGet(System.Int64)">
            <summary>Returns true or false for the specified bit index.
            The index should be less than the OpenBitSet size.
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.OpenBitSet.GetBit(System.Int32)">
            <summary>returns 1 if the bit is set, 0 if not.
            The index should be less than the OpenBitSet size
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.OpenBitSet.Set(System.Int64)">
            <summary>sets a bit, expanding the set size if necessary </summary>
        </member>
        <member name="M:Lucene.Net.Util.OpenBitSet.FastSet(System.Int32)">
            <summary>Sets the bit at the specified index.
            The index should be less than the OpenBitSet size.
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.OpenBitSet.FastSet(System.Int64)">
            <summary>Sets the bit at the specified index.
            The index should be less than the OpenBitSet size.
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.OpenBitSet.Set(System.Int64,System.Int64)">
            <summary>Sets a range of bits, expanding the set size if necessary
            
            </summary>
            <param name="startIndex">lower index
            </param>
            <param name="endIndex">one-past the last bit to set
            </param>
        </member>
        <member name="M:Lucene.Net.Util.OpenBitSet.FastClear(System.Int32)">
            <summary>clears a bit.
            The index should be less than the OpenBitSet size.
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.OpenBitSet.FastClear(System.Int64)">
            <summary>clears a bit.
            The index should be less than the OpenBitSet size.
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.OpenBitSet.Clear(System.Int64)">
            <summary>clears a bit, allowing access beyond the current set size without changing the size.</summary>
        </member>
        <member name="M:Lucene.Net.Util.OpenBitSet.Clear(System.Int32,System.Int32)">
            <summary>Clears a range of bits.  Clearing past the end does not change the size of the set.
            
            </summary>
            <param name="startIndex">lower index
            </param>
            <param name="endIndex">one-past the last bit to clear
            </param>
        </member>
        <member name="M:Lucene.Net.Util.OpenBitSet.Clear(System.Int64,System.Int64)">
            <summary>Clears a range of bits.  Clearing past the end does not change the size of the set.
            
            </summary>
            <param name="startIndex">lower index
            </param>
            <param name="endIndex">one-past the last bit to clear
            </param>
        </member>
        <member name="M:Lucene.Net.Util.OpenBitSet.GetAndSet(System.Int32)">
            <summary>Sets a bit and returns the previous value.
            The index should be less than the OpenBitSet size.
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.OpenBitSet.GetAndSet(System.Int64)">
            <summary>Sets a bit and returns the previous value.
            The index should be less than the OpenBitSet size.
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.OpenBitSet.FastFlip(System.Int32)">
            <summary>flips a bit.
            The index should be less than the OpenBitSet size.
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.OpenBitSet.FastFlip(System.Int64)">
            <summary>flips a bit.
            The index should be less than the OpenBitSet size.
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.OpenBitSet.Flip(System.Int64)">
            <summary>flips a bit, expanding the set size if necessary </summary>
        </member>
        <member name="M:Lucene.Net.Util.OpenBitSet.FlipAndGet(System.Int32)">
            <summary>flips a bit and returns the resulting bit value.
            The index should be less than the OpenBitSet size.
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.OpenBitSet.FlipAndGet(System.Int64)">
            <summary>flips a bit and returns the resulting bit value.
            The index should be less than the OpenBitSet size.
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.OpenBitSet.Flip(System.Int64,System.Int64)">
            <summary>Flips a range of bits, expanding the set size if necessary
            
            </summary>
            <param name="startIndex">lower index
            </param>
            <param name="endIndex">one-past the last bit to flip
            </param>
        </member>
        <member name="M:Lucene.Net.Util.OpenBitSet.Cardinality">
            <returns> the number of set bits 
            </returns>
        </member>
        <member name="M:Lucene.Net.Util.OpenBitSet.IntersectionCount(Lucene.Net.Util.OpenBitSet,Lucene.Net.Util.OpenBitSet)">
            <summary>Returns the popcount or cardinality of the intersection of the two sets.
            Neither set is modified.
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.OpenBitSet.UnionCount(Lucene.Net.Util.OpenBitSet,Lucene.Net.Util.OpenBitSet)">
            <summary>Returns the popcount or cardinality of the union of the two sets.
            Neither set is modified.
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.OpenBitSet.AndNotCount(Lucene.Net.Util.OpenBitSet,Lucene.Net.Util.OpenBitSet)">
            <summary>Returns the popcount or cardinality of "a and not b"
            or "intersection(a, not(b))".
            Neither set is modified.
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.OpenBitSet.XorCount(Lucene.Net.Util.OpenBitSet,Lucene.Net.Util.OpenBitSet)">
            <summary>Returns the popcount or cardinality of the exclusive-or of the two sets.
            Neither set is modified.
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.OpenBitSet.NextSetBit(System.Int32)">
            <summary>Returns the index of the first set bit starting at the index specified.
            -1 is returned if there are no more set bits.
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.OpenBitSet.NextSetBit(System.Int64)">
            <summary>Returns the index of the first set bit starting at the index specified.
            -1 is returned if there are no more set bits.
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.OpenBitSet.Intersect(Lucene.Net.Util.OpenBitSet)">
            <summary>this = this AND other </summary>
        </member>
        <member name="M:Lucene.Net.Util.OpenBitSet.Union(Lucene.Net.Util.OpenBitSet)">
            <summary>this = this OR other </summary>
        </member>
        <member name="M:Lucene.Net.Util.OpenBitSet.Remove(Lucene.Net.Util.OpenBitSet)">
            <summary>Remove all elements set in other. this = this AND_NOT other </summary>
        </member>
        <member name="M:Lucene.Net.Util.OpenBitSet.Xor(Lucene.Net.Util.OpenBitSet)">
            <summary>this = this XOR other </summary>
        </member>
        <member name="M:Lucene.Net.Util.OpenBitSet.Intersects(Lucene.Net.Util.OpenBitSet)">
            <summary>returns true if the sets have any elements in common </summary>
        </member>
        <member name="M:Lucene.Net.Util.OpenBitSet.EnsureCapacityWords(System.Int32)">
            <summary>Expand the long[] with the size given as a number of words (64 bit longs).
            getNumWords() is unchanged by this call.
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.OpenBitSet.EnsureCapacity(System.Int64)">
            <summary>Ensure that the long[] is big enough to hold numBits, expanding it if necessary.
            getNumWords() is unchanged by this call.
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.OpenBitSet.TrimTrailingZeros">
            <summary>Lowers numWords, the number of words in use,
            by checking for trailing zero words.
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.OpenBitSet.Bits2words(System.Int64)">
            <summary>returns the number of 64 bit words it would take to hold numBits </summary>
        </member>
        <member name="M:Lucene.Net.Util.OpenBitSet.Equals(System.Object)">
            <summary>returns true if both sets have the same bits set </summary>
        </member>
        <member name="M:Lucene.Net.Util.OpenBitSetDISI.#ctor(Lucene.Net.Search.DocIdSetIterator,System.Int32)">
            <summary>Construct an OpenBitSetDISI with its bits set
            from the doc ids of the given DocIdSetIterator.
            Also give a maximum size one larger than the largest doc id for which a
            bit may ever be set on this OpenBitSetDISI.
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.OpenBitSetDISI.#ctor(System.Int32)">
            <summary>Construct an OpenBitSetDISI with no bits set, and a given maximum size
            one larger than the largest doc id for which a bit may ever be set
            on this OpenBitSetDISI.
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.OpenBitSetDISI.InPlaceOr(Lucene.Net.Search.DocIdSetIterator)">
            <summary> Perform an inplace OR with the doc ids from a given DocIdSetIterator,
            setting the bit for each such doc id.
            These doc ids should be smaller than the maximum size passed to the
            constructor.
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.OpenBitSetDISI.InPlaceAnd(Lucene.Net.Search.DocIdSetIterator)">
            <summary> Perform an inplace AND with the doc ids from a given DocIdSetIterator,
            leaving only the bits set for which the doc ids are in common.
            These doc ids should be smaller than the maximum size passed to the
            constructor.
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.OpenBitSetDISI.InPlaceNot(Lucene.Net.Search.DocIdSetIterator)">
            <summary> Perform an inplace NOT with the doc ids from a given DocIdSetIterator,
            clearing all the bits for each such doc id.
            These doc ids should be smaller than the maximum size passed to the
            constructor.
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.OpenBitSetDISI.InPlaceXor(Lucene.Net.Search.DocIdSetIterator)">
            <summary> Perform an inplace XOR with the doc ids from a given DocIdSetIterator,
            flipping all the bits for each such doc id.
            These doc ids should be smaller than the maximum size passed to the
            constructor.
            </summary>
        </member>
        <member name="T:Lucene.Net.Store.SimpleFSLockFactory">
            <summary> <p/>Implements {@link LockFactory} using {@link
            File#createNewFile()}.<p/>
            
            <p/><b>NOTE:</b> the <a target="_top" href="http://java.sun.com/j2se/1.4.2/docs/api/java/io/File.html#createNewFile()">javadocs
            for <code>File.createNewFile</code></a> contain a vague
            yet spooky warning about not using the API for file
            locking.  This warning was added due to <a target="_top" href="http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4676183">this
            bug</a>, and in fact the only known problem with using
            this API for locking is that the Lucene write lock may
            not be released when the JVM exits abnormally.<p/>
            <p/>When this happens, a {@link LockObtainFailedException}
            is hit when trying to create a writer, in which case you
            need to explicitly clear the lock file first.  You can
            either manually remove the file, or use the {@link
            org.apache.lucene.index.IndexReader#unlock(Directory)}
            API.  But, first be certain that no writer is in fact
            writing to the index otherwise you can easily corrupt
            your index.<p/>
            
            <p/>If you suspect that this or any other LockFactory is
            not working properly in your environment, you can easily
            test it by using {@link VerifyingLockFactory}, {@link
            LockVerifyServer} and {@link LockStressTest}.<p/>
            
            </summary>
            <seealso cref="T:Lucene.Net.Store.LockFactory">
            </seealso>
        </member>
        <member name="T:Lucene.Net.Store.FSLockFactory">
            <summary> Base class for file system based locking implementation.</summary>
        </member>
        <member name="T:Lucene.Net.Store.LockFactory">
            <summary> <p/>Base class for Locking implementation.  {@link Directory} uses
            instances of this class to implement locking.<p/>
            
            <p/>Note that there are some useful tools to verify that
            your LockFactory is working correctly: {@link
            VerifyingLockFactory}, {@link LockStressTest}, {@link
            LockVerifyServer}.<p/>
            
            </summary>
            <seealso cref="T:Lucene.Net.Store.LockVerifyServer">
            </seealso>
            <seealso cref="T:Lucene.Net.Store.LockStressTest">
            </seealso>
            <seealso cref="T:Lucene.Net.Store.VerifyingLockFactory">
            </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>
        <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.
            </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>
        </member>
        <member name="F:Lucene.Net.Store.FSLockFactory.lockDir">
            <summary> Directory for the lock files.</summary>
        </member>
        <member name="M:Lucene.Net.Store.FSLockFactory.SetLockDir(System.IO.DirectoryInfo)">
            <summary> Set the lock directory. This method can be only called
            once to initialize the lock directory. It is used by {@link FSDirectory}
            to set the lock directory to itsself.
            Subclasses can also use this method to set the directory
            in the constructor.
            </summary>
        </member>
        <member name="M:Lucene.Net.Store.FSLockFactory.GetLockDir">
            <summary> Retrieve the lock directory.</summary>
        </member>
        <member name="M:Lucene.Net.Store.SimpleFSLockFactory.#ctor">
            <summary> Create a SimpleFSLockFactory instance, with null (unset)
            lock directory. When you pass this factory to a {@link FSDirectory}
            subclass, the lock directory is automatically set to the
            directory itsself. Be sure to create one instance for each directory
            your create!
            </summary>
        </member>
        <member name="M:Lucene.Net.Store.SimpleFSLockFactory.#ctor(System.IO.FileInfo)">
            <summary> Instantiate using the provided directory (as a File instance).</summary>
            <param name="lockDir">where lock files should be created.
            </param>
        </member>
        <member name="M:Lucene.Net.Store.SimpleFSLockFactory.#ctor(System.IO.DirectoryInfo)">
            <summary> Instantiate using the provided directory (as a File instance).</summary>
            <param name="lockDir">where lock files should be created.
            </param>
        </member>
        <member name="M:Lucene.Net.Store.SimpleFSLockFactory.#ctor(System.String)">
            <summary> Instantiate using the provided directory name (String).</summary>
            <param name="lockDirName">where lock files should be created.
            </param>
        </member>
        <member name="T:Lucene.Net.Store.Lock">
            <summary>An interprocess mutex lock.
            <p/>Typical use might look like:<pre>
            new Lock.With(directory.makeLock("my.lock")) {
            public Object doBody() {
            <i>... code to execute while locked ...</i>
            }
            }.run();
            </pre>
            
            
            </summary>
            <version>  $Id: Lock.java 769409 2009-04-28 14:05:43Z mikemccand $
            </version>
            <seealso cref="M:Lucene.Net.Store.Directory.MakeLock(System.String)">
            </seealso>
        </member>
        <member name="F:Lucene.Net.Store.Lock.LOCK_OBTAIN_WAIT_FOREVER">
            <summary>Pass this value to {@link #Obtain(long)} to try
            forever to obtain the lock. 
            </summary>
        </member>
        <member name="F:Lucene.Net.Store.Lock.LOCK_POLL_INTERVAL">
            <summary>How long {@link #Obtain(long)} waits, in milliseconds,
            in between attempts to acquire the lock. 
            </summary>
        </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>
        <member name="F:Lucene.Net.Store.Lock.failureReason">
            <summary> If a lock obtain called, this failureReason may be set
            with the "root cause" Exception as to why the lock was
            not obtained.
            </summary>
        </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.
            </summary>
            <param name="lockWaitTimeout">length of time to wait in
            milliseconds or {@link
            #LOCK_OBTAIN_WAIT_FOREVER} to retry forever
            </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>
        </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. 
            </summary>
        </member>
        <member name="T:Lucene.Net.Store.Lock.With">
            <summary>Utility class for executing code with exclusive access. </summary>
        </member>
        <member name="M:Lucene.Net.Store.Lock.With.#ctor(Lucene.Net.Store.Lock,System.Int64)">
            <summary>Constructs an executor that will grab the named lock. </summary>
        </member>
        <member name="M:Lucene.Net.Store.Lock.With.DoBody">
            <summary>Code to execute with exclusive access. </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
            </summary>
            <throws>  IOException if {@link Lock#obtain} throws IOException </throws>
        </member>
        <member name="T:Lucene.Net.Store.SimpleFSDirectory">
            <summary>A straightforward implementation of {@link FSDirectory}
            using java.io.RandomAccessFile.  However, this class has
            poor concurrent performance (multiple threads will
            bottleneck) as it synchronizes when multiple threads
            read from the same file.  It's usually better to use
            {@link NIOFSDirectory} or {@link MMapDirectory} instead. 
            </summary>
        </member>
        <!-- Badly formed XML comment ignored for member "T:Lucene.Net.Store.FSDirectory" -->
        <member name="T:Lucene.Net.Store.Directory">
            <summary>A Directory is a flat list of files.  Files may be written once, when they
            are created.  Once a file is created it may only be opened for read, or
            deleted.  Random access is permitted both when reading and writing.
            
            <p/> Java's i/o APIs not used directly, but rather all i/o is
            through this API.  This permits things such as: <ul>
            <li> implementation of RAM-based indices;</li>
            <li> implementation indices stored in a database, via JDBC;</li>
            <li> implementation of an index as a single file;</li>
            </ul>
            
            Directory locking is implemented by an instance of {@link
            LockFactory}, and can be changed for each Directory
            instance using {@link #setLockFactory}.
            
            </summary>
        </member>
        <member name="F:Lucene.Net.Store.Directory.lockFactory">
            <summary>Holds the LockFactory instance (implements locking for
            this Directory instance). 
            </summary>
        </member>
        <member name="M:Lucene.Net.Store.Directory.List">
            <deprecated> For some Directory implementations ({@link
            FSDirectory}, and its subclasses), this method
            silently filters its results to include only index
            files.  Please use {@link #listAll} instead, which
            does no filtering. 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Store.Directory.ListAll">
            <summary>Returns an array of strings, one for each file in the
            directory.  Unlike {@link #list} this method does no
            filtering of the contents in a directory, and it will
            never return null (throws IOException instead).
            
            Currently this method simply fallsback to {@link
            #list} for Directory impls outside of Lucene's core &amp;
            contrib, but in 3.0 that method will be removed and
            this method will become abstract. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Store.Directory.FileExists(System.String)">
            <summary>Returns true iff a file with the given name exists. </summary>
        </member>
        <member name="M:Lucene.Net.Store.Directory.FileModified(System.String)">
            <summary>Returns the time the named file was last modified. </summary>
        </member>
        <member name="M:Lucene.Net.Store.Directory.TouchFile(System.String)">
            <summary>Set the modified time of an existing file to now. </summary>
        </member>
        <member name="M:Lucene.Net.Store.Directory.DeleteFile(System.String)">
            <summary>Removes an existing file in the directory. </summary>
        </member>
        <member name="M:Lucene.Net.Store.Directory.RenameFile(System.String,System.String)">
            <summary>Renames an existing file in the directory.
            If a file already exists with the new name, then it is replaced.
            This replacement is not guaranteed to be atomic.
            </summary>
            <deprecated> 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Store.Directory.FileLength(System.String)">
            <summary>Returns the length of a file in the directory. </summary>
        </member>
        <member name="M:Lucene.Net.Store.Directory.CreateOutput(System.String)">
            <summary>Creates a new, empty file in the directory with the given name.
            Returns a stream writing this file. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Store.Directory.Sync(System.String)">
            <summary>Ensure that any writes to this file are moved to
            stable storage.  Lucene uses this to properly commit
            changes to the index, to prevent a machine/OS crash
            from corrupting the index. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Store.Directory.OpenInput(System.String)">
            <summary>Returns a stream reading an existing file. </summary>
        </member>
        <member name="M:Lucene.Net.Store.Directory.OpenInput(System.String,System.Int32)">
            <summary>Returns a stream reading an existing file, with the
            specified read buffer size.  The particular Directory
            implementation may ignore the buffer size.  Currently
            the only Directory implementations that respect this
            parameter are {@link FSDirectory} and {@link
            Lucene.Net.Index.CompoundFileReader}.
            </summary>
        </member>
        <member name="M:Lucene.Net.Store.Directory.MakeLock(System.String)">
            <summary>Construct a {@link Lock}.</summary>
            <param name="name">the name of the lock file
            </param>
        </member>
        <member name="M:Lucene.Net.Store.Directory.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="name">name of the lock to be cleared.
            </param>
        </member>
        <member name="M:Lucene.Net.Store.Directory.Close">
            <summary>Closes the store. </summary>
        </member>
        <member name="M:Lucene.Net.Store.Directory.SetLockFactory(Lucene.Net.Store.LockFactory)">
            <summary> Set the LockFactory that this Directory instance should
            use for its locking implementation.  Each * instance of
            LockFactory should only be used for one directory (ie,
            do not share a single instance across multiple
            Directories).
            
            </summary>
            <param name="lockFactory">instance of {@link LockFactory}.
            </param>
        </member>
        <member name="M:Lucene.Net.Store.Directory.GetLockFactory">
            <summary> Get the LockFactory that this Directory instance is
            using for its locking implementation.  Note that this
            may be null for Directory implementations that provide
            their own locking implementation.
            </summary>
        </member>
        <member name="M:Lucene.Net.Store.Directory.GetLockID">
            <summary> Return a string identifier that uniquely differentiates
            this Directory instance from other Directory instances.
            This ID should be the same if two Directory instances
            (even in different JVMs and/or on different machines)
            are considered "the same index".  This is how locking
            "scopes" to the right index.
            </summary>
        </member>
        <member name="M:Lucene.Net.Store.Directory.Copy(Lucene.Net.Store.Directory,Lucene.Net.Store.Directory,System.Boolean)">
            <summary> Copy contents of a directory src to a directory dest.
            If a file in src already exists in dest then the
            one in dest will be blindly overwritten.
            
            <p/><b>NOTE:</b> the source directory cannot change
            while this method is running.  Otherwise the results
            are undefined and you could easily hit a
            FileNotFoundException.
            
            <p/><b>NOTE:</b> this method only copies files that look
            like index files (ie, have extensions matching the
            known extensions of index files).
            
            </summary>
            <param name="src">source directory
            </param>
            <param name="dest">destination directory
            </param>
            <param name="closeDirSrc">if <code>true</code>, call {@link #Close()} method on source directory
            </param>
            <throws>  IOException </throws>
        </member>
        <member name="M:Lucene.Net.Store.Directory.EnsureOpen">
            <throws>  AlreadyClosedException if this Directory is closed </throws>
        </member>
        <member name="F:Lucene.Net.Store.FSDirectory.DIRECTORIES">
            <summary>This cache of directories ensures that there is a unique Directory
            instance per path, so that synchronization on the Directory can be used to
            synchronize access between readers and writers.  We use
            refcounts to ensure when the last use of an FSDirectory
            instance for a given canonical path is closed, we remove the
            instance from the cache.  See LUCENE-776
            for some relevant discussion.
            </summary>
            <deprecated> Not used by any non-deprecated methods anymore
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Store.FSDirectory.SetDisableLocks(System.Boolean)">
            <summary> Set whether Lucene's use of lock files is disabled. By default, 
            lock files are enabled. They should only be disabled if the index
            is on a read-only medium like a CD-ROM.
            </summary>
            <deprecated> Use a {@link #open(File, LockFactory)} or a constructor
            that takes a {@link LockFactory} and supply
            {@link NoLockFactory#getNoLockFactory}. This setting does not work
            with {@link #open(File)} only the deprecated <code>getDirectory</code>
            respect this setting.   
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Store.FSDirectory.GetDisableLocks">
            <summary> Returns whether Lucene's use of lock files is disabled.</summary>
            <returns> true if locks are disabled, false if locks are enabled.
            </returns>
            <seealso cref="!:setDisableLocks">
            </seealso>
            <deprecated> Use a constructor that takes a {@link LockFactory} and
            supply {@link NoLockFactory#getNoLockFactory}.
            </deprecated>
        </member>
        <member name="F:Lucene.Net.Store.FSDirectory.IMPL">
            <summary>The default class which implements filesystem-based directories. </summary>
        </member>
        <member name="F:Lucene.Net.Store.FSDirectory.buffer">
            <summary>A buffer optionally used in renameTo method </summary>
        </member>
        <member name="M:Lucene.Net.Store.FSDirectory.GetDirectory(System.String)">
            <summary>Returns the directory instance for the named location.
            
            </summary>
            <deprecated> Use {@link #Open(File)}
            
            </deprecated>
            <param name="path">the path to the directory.
            </param>
            <returns> the FSDirectory for the named file.  
            </returns>
        </member>
        <member name="M:Lucene.Net.Store.FSDirectory.GetDirectory(System.String,Lucene.Net.Store.LockFactory)">
            <summary>Returns the directory instance for the named location.
            
            </summary>
            <deprecated> Use {@link #Open(File, LockFactory)}
            
            </deprecated>
            <param name="path">the path to the directory.
            </param>
            <param name="lockFactory">instance of {@link LockFactory} providing the
            locking implementation.
            </param>
            <returns> the FSDirectory for the named file.  
            </returns>
        </member>
        <member name="M:Lucene.Net.Store.FSDirectory.GetDirectory(System.IO.DirectoryInfo)">
            <summary>Returns the directory instance for the named location.
            
            </summary>
            <deprecated> Use {@link #Open(File)}
            
            </deprecated>
            <param name="file">the path to the directory.
            </param>
            <returns> the FSDirectory for the named file.  
            </returns>
        </member>
        <member name="M:Lucene.Net.Store.FSDirectory.GetDirectory(System.IO.FileInfo)">
            <summary>Returns the directory instance for the named location.
            
            </summary>
            <deprecated> Use {@link #Open(File)}
            
            </deprecated>
            <param name="file">the path to the directory.
            </param>
            <returns> the FSDirectory for the named file.  
            </returns>
        </member>
        <member name="M:Lucene.Net.Store.FSDirectory.GetDirectory(System.IO.FileInfo,Lucene.Net.Store.LockFactory)">
            <summary>Returns the directory instance for the named location.
            
            </summary>
            <deprecated> Use {@link #Open(File, LockFactory)}
            
            </deprecated>
            <param name="file">the path to the directory.
            </param>
            <param name="lockFactory">instance of {@link LockFactory} providing the
            locking implementation.
            </param>
            <returns> the FSDirectory for the named file.  
            </returns>
        </member>
        <member name="M:Lucene.Net.Store.FSDirectory.GetDirectory(System.IO.DirectoryInfo,Lucene.Net.Store.LockFactory)">
            <summary>Returns the directory instance for the named location.
            
            </summary>
            <deprecated> Use {@link #Open(File, LockFactory)}
            
            </deprecated>
            <param name="file">the path to the directory.
            </param>
            <param name="lockFactory">instance of {@link LockFactory} providing the
            locking implementation.
            </param>
            <returns> the FSDirectory for the named file.  
            </returns>
        </member>
        <member name="M:Lucene.Net.Store.FSDirectory.GetDirectory(System.String,System.Boolean)">
            <summary>Returns the directory instance for the named location.
            
            </summary>
            <deprecated> Use IndexWriter's create flag, instead, to
            create a new index.
            
            </deprecated>
            <param name="path">the path to the directory.
            </param>
            <param name="create">if true, create, or erase any existing contents.
            </param>
            <returns> the FSDirectory for the named file.  
            </returns>
        </member>
        <member name="M:Lucene.Net.Store.FSDirectory.GetDirectory(System.IO.FileInfo,System.Boolean)">
            <summary>Returns the directory instance for the named location.
            
            </summary>
            <deprecated> Use IndexWriter's create flag, instead, to
            create a new index.
            
            </deprecated>
            <param name="file">the path to the directory.
            </param>
            <param name="create">if true, create, or erase any existing contents.
            </param>
            <returns> the FSDirectory for the named file.  
            </returns>
        </member>
        <member name="M:Lucene.Net.Store.FSDirectory.GetDirectory(System.IO.DirectoryInfo,System.Boolean)">
            <summary>Returns the directory instance for the named location.
            
            </summary>
            <deprecated> Use IndexWriter's create flag, instead, to
            create a new index.
            
            </deprecated>
            <param name="file">the path to the directory.
            </param>
            <param name="create">if true, create, or erase any existing contents.
            </param>
            <returns> the FSDirectory for the named file.  
            </returns>
        </member>
        <member name="M:Lucene.Net.Store.FSDirectory.Create">
            <deprecated> 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Store.FSDirectory.InitOutput(System.String)">
            <summary>Initializes the directory to create a new file with the given name.
            This method should be used in {@link #createOutput}. 
            </summary>
        </member>
        <member name="F:Lucene.Net.Store.FSDirectory.directory">
            <summary>The underlying filesystem directory </summary>
        </member>
        <member name="F:Lucene.Net.Store.FSDirectory.refCount">
            <deprecated> 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Store.FSDirectory.#ctor">
            <deprecated> 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Store.FSDirectory.#ctor(System.IO.DirectoryInfo,Lucene.Net.Store.LockFactory)">
            <summary>Create a new FSDirectory for the named location (ctor for subclasses).</summary>
            <param name="path">the path of the directory
            </param>
            <param name="lockFactory">the lock factory to use, or null for the default
            ({@link NativeFSLockFactory});
            </param>
            <throws>  IOException </throws>
        </member>
        <member name="M:Lucene.Net.Store.FSDirectory.Open(System.IO.FileInfo)">
            <summary>Creates an FSDirectory instance, trying to pick the
            best implementation given the current environment.
            The directory returned uses the {@link NativeFSLockFactory}.
            
            <p/>Currently this returns {@link SimpleFSDirectory} as
            NIOFSDirectory is currently not supported.
            
            <p/>Currently this returns {@link SimpleFSDirectory} as
            NIOFSDirectory is currently not supported.
            
            <p/><b>NOTE</b>: this method may suddenly change which
            implementation is returned from release to release, in
            the event that higher performance defaults become
            possible; if the precise implementation is important to
            your application, please instantiate it directly,
            instead. On 64 bit systems, it may also good to
            return {@link MMapDirectory}, but this is disabled
            because of officially missing unmap support in Java.
            For optimal performance you should consider using
            this implementation on 64 bit JVMs.
            
            <p/>See <a href="#subclasses">above</a> 
            </summary>
        </member>
        <member name="M:Lucene.Net.Store.FSDirectory.Open(System.IO.DirectoryInfo)">
            <summary>Creates an FSDirectory instance, trying to pick the
            best implementation given the current environment.
            The directory returned uses the {@link NativeFSLockFactory}.
            
            <p/>Currently this returns {@link SimpleFSDirectory} as
            NIOFSDirectory is currently not supported.
            
            <p/><b>NOTE</b>: this method may suddenly change which
            implementation is returned from release to release, in
            the event that higher performance defaults become
            possible; if the precise implementation is important to
            your application, please instantiate it directly,
            instead. On 64 bit systems, it may also good to
            return {@link MMapDirectory}, but this is disabled
            because of officially missing unmap support in Java.
            For optimal performance you should consider using
            this implementation on 64 bit JVMs.
            
            <p/>See <a href="#subclasses">above</a> 
            </summary>
        </member>
        <member name="M:Lucene.Net.Store.FSDirectory.Open(System.IO.DirectoryInfo,Lucene.Net.Store.LockFactory)">
            <summary>Just like {@link #Open(File)}, but allows you to
            also specify a custom {@link LockFactory}. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Store.FSDirectory.ListAll(System.IO.FileInfo)">
            <summary>Lists all files (not subdirectories) in the
            directory.  This method never returns null (throws
            {@link IOException} instead).
            
            </summary>
            <throws>  NoSuchDirectoryException if the directory </throws>
            <summary>   does not exist, or does exist but is not a
            directory.
            </summary>
            <throws>  IOException if list() returns null  </throws>
        </member>
        <member name="M:Lucene.Net.Store.FSDirectory.ListAll(System.IO.DirectoryInfo)">
            <summary>Lists all files (not subdirectories) in the
            directory.  This method never returns null (throws
            {@link IOException} instead).
            
            </summary>
            <throws>  NoSuchDirectoryException if the directory </throws>
            <summary>   does not exist, or does exist but is not a
            directory.
            </summary>
            <throws>  IOException if list() returns null  </throws>
        </member>
        <member name="M:Lucene.Net.Store.FSDirectory.ListAll">
            <summary>Lists all files (not subdirectories) in the
            directory.
            </summary>
            <seealso cref="!:ListAll(File)">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Store.FSDirectory.FileExists(System.String)">
            <summary>Returns true iff a file with the given name exists. </summary>
        </member>
        <member name="M:Lucene.Net.Store.FSDirectory.FileModified(System.String)">
            <summary>Returns the time the named file was last modified. </summary>
        </member>
        <member name="M:Lucene.Net.Store.FSDirectory.FileModified(System.IO.FileInfo,System.String)">
            <summary>Returns the time the named file was last modified. </summary>
        </member>
        <member name="M:Lucene.Net.Store.FSDirectory.TouchFile(System.String)">
            <summary>Set the modified time of an existing file to now. </summary>
        </member>
        <member name="M:Lucene.Net.Store.FSDirectory.FileLength(System.String)">
            <summary>Returns the length in bytes of a file in the directory. </summary>
        </member>
        <member name="M:Lucene.Net.Store.FSDirectory.DeleteFile(System.String)">
            <summary>Removes an existing file in the directory. </summary>
        </member>
        <member name="M:Lucene.Net.Store.FSDirectory.RenameFile(System.String,System.String)">
            <summary>Renames an existing file in the directory. 
            Warning: This is not atomic.
            </summary>
            <deprecated> 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Store.FSDirectory.CreateOutput(System.String)">
            <summary>Creates an IndexOutput for the file with the given name.
            <em>In 3.0 this method will become abstract.</em> 
            </summary>
        </member>
        <member name="M:Lucene.Net.Store.FSDirectory.OpenInput(System.String,System.Int32)">
            <summary>Creates an IndexInput for the file with the given name.
            <em>In 3.0 this method will become abstract.</em> 
            </summary>
        </member>
        <member name="F:Lucene.Net.Store.FSDirectory.HEX_DIGITS">
            <summary> So we can do some byte-to-hexchar conversion below</summary>
        </member>
        <member name="M:Lucene.Net.Store.FSDirectory.Close">
            <summary>Closes the store to future operations. </summary>
        </member>
        <member name="M:Lucene.Net.Store.FSDirectory.Dispose">
            <summary>
            .NET
            </summary>
        </member>
        <member name="M:Lucene.Net.Store.FSDirectory.ToString">
            <summary>For debug output. </summary>
        </member>
        <member name="F:Lucene.Net.Store.FSDirectory.DEFAULT_READ_CHUNK_SIZE">
            <summary> Default read chunk size.  This is a conditional
            default: on 32bit JVMs, it defaults to 100 MB.  On
            64bit JVMs, it's <code>Integer.MAX_VALUE</code>.
            </summary>
            <seealso cref="!:setReadChunkSize">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Store.FSDirectory.SetReadChunkSize(System.Int32)">
            <summary> Sets the maximum number of bytes read at once from the
            underlying file during {@link IndexInput#readBytes}.
            The default value is {@link #DEFAULT_READ_CHUNK_SIZE};
            
            <p/> This was introduced due to <a
            href="http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6478546">Sun
            JVM Bug 6478546</a>, which throws an incorrect
            OutOfMemoryError when attempting to read too many bytes
            at once.  It only happens on 32bit JVMs with a large
            maximum heap size.<p/>
            
            <p/>Changes to this value will not impact any
            already-opened {@link IndexInput}s.  You should call
            this before attempting to open an index on the
            directory.<p/>
            
            <p/> <b>NOTE</b>: This value should be as large as
            possible to reduce any possible performance impact.  If
            you still encounter an incorrect OutOfMemoryError,
            trying lowering the chunk size.<p/>
            </summary>
        </member>
        <member name="M:Lucene.Net.Store.FSDirectory.GetReadChunkSize">
            <summary> The maximum number of bytes to read at once from the
            underlying file during {@link IndexInput#readBytes}.
            </summary>
            <seealso cref="!:setReadChunkSize">
            </seealso>
        </member>
        <member name="T:Lucene.Net.Store.FSDirectory.FSIndexInput">
            <deprecated> Use SimpleFSDirectory.SimpleFSIndexInput instead 
            </deprecated>
        </member>
        <member name="T:Lucene.Net.Store.BufferedIndexInput">
            <summary>Base implementation class for buffered {@link IndexInput}. </summary>
        </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>
        </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>
        <member name="M:Lucene.Net.Store.IndexInput.ReadBytes(System.Byte[],System.Int32,System.Int32,System.Boolean)">
            <summary>Reads a specified number of bytes into an array at the
            specified offset with control over whether the read
            should be buffered (callers who have their own buffer
            should pass in "false" for useBuffer).  Currently only
            {@link BufferedIndexInput} respects this parameter.
            </summary>
            <param name="b">the array to read bytes into
            </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>
        </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.
            </summary>
            <seealso cref="M:Lucene.Net.Store.IndexOutput.WriteVInt(System.Int32)">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Store.IndexInput.ReadLong">
            <summary>Reads eight bytes and returns a long.</summary>
            <seealso cref="M:Lucene.Net.Store.IndexOutput.WriteLong(System.Int64)">
            </seealso>
        </member>
        <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. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Store.IndexInput.SetModifiedUTF8StringsMode">
            <summary>Call this if readString should read characters stored
            in the old modified UTF8 format (length in java chars
            and java's modified UTF8 encoding).  This is used for
            indices written pre-2.4 See LUCENE-510 for details. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Store.IndexInput.ReadString">
            <summary>Reads a string.</summary>
            <seealso cref="M:Lucene.Net.Store.IndexOutput.WriteString(System.String)">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Store.IndexInput.ReadChars(System.Char[],System.Int32,System.Int32)">
            <summary>Reads Lucene's old "modified UTF-8" encoded
            characters into an array.
            </summary>
            <param name="buffer">the array to read characters into
            </param>
            <param name="start">the offset in the array to start storing characters
            </param>
            <param name="length">the number of characters to read
            </param>
            <seealso cref="M:Lucene.Net.Store.IndexOutput.WriteChars(System.String,System.Int32,System.Int32)">
            </seealso>
            <deprecated> -- please use readString or readBytes
            instead, and construct the string
            from those utf8 bytes
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Store.IndexInput.SkipChars(System.Int32)">
            <summary> Expert
            
            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
            </summary>
            <param name="length">The number of chars to read
            </param>
            <deprecated> this method operates on old "modified utf8" encoded
            strings
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Store.IndexInput.Close">
            <summary>Closes the stream to futher operations. </summary>
        </member>
        <member name="M:Lucene.Net.Store.IndexInput.GetFilePointer">
            <summary>Returns the current position in this file, where the next read will
            occur.
            </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>
        <member name="M:Lucene.Net.Store.IndexInput.Clone">
            <summary>Returns a clone of this stream.
            
            <p/>Clones of a stream access the same data, and are positioned at the same
            point as the stream they were cloned from.
            
            <p/>Expert: Subclasses must ensure that clones may be positioned at
            different points in the input from each other and from the stream they
            were cloned from.
            </summary>
        </member>
        <member name="F:Lucene.Net.Store.BufferedIndexInput.BUFFER_SIZE">
            <summary>Default buffer size </summary>
        </member>
        <member name="M:Lucene.Net.Store.BufferedIndexInput.#ctor(System.Int32)">
            <summary>Inits BufferedIndexInput with a specific bufferSize </summary>
        </member>
        <member name="M:Lucene.Net.Store.BufferedIndexInput.SetBufferSize(System.Int32)">
            <summary>Change the buffer size used by this IndexInput </summary>
        </member>
        <member name="M:Lucene.Net.Store.BufferedIndexInput.GetBufferSize">
            <seealso cref="!:setBufferSize">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Store.BufferedIndexInput.ReadInternal(System.Byte[],System.Int32,System.Int32)">
            <summary>Expert: implements buffer refill.  Reads bytes from the current position
            in the input.
            </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="length">the number of bytes to read
            </param>
        </member>
        <member name="M:Lucene.Net.Store.BufferedIndexInput.SeekInternal(System.Int64)">
            <summary>Expert: implements seek.  Sets current position in this file, where the
            next {@link #ReadInternal(byte[],int,int)} will occur.
            </summary>
            <seealso cref="M:Lucene.Net.Store.BufferedIndexInput.ReadInternal(System.Byte[],System.Int32,System.Int32)">
            </seealso>
        </member>
        <member name="T:Lucene.Net.Store.SimpleFSDirectory">
            <summary>A straightforward implementation of {@link FSDirectory}
            using java.io.RandomAccessFile.  However, this class has
            poor concurrent performance (multiple threads will
            bottleneck) as it synchronizes when multiple threads
            read from the same file.  It's usually better to use
            {@link NIOFSDirectory} or {@link MMapDirectory} instead. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Store.SimpleFSDirectory.#ctor(System.IO.FileInfo,Lucene.Net.Store.LockFactory)">
            <summary>Create a new SimpleFSDirectory for the named location.
            
            </summary>
            <param name="path">the path of the directory
            </param>
            <param name="lockFactory">the lock factory to use, or null for the default.
            </param>
            <throws>  IOException </throws>
        </member>
        <member name="M:Lucene.Net.Store.SimpleFSDirectory.#ctor(System.IO.DirectoryInfo,Lucene.Net.Store.LockFactory)">
            <summary>Create a new SimpleFSDirectory for the named location.
            
            </summary>
            <param name="path">the path of the directory
            </param>
            <param name="lockFactory">the lock factory to use, or null for the default.
            </param>
            <throws>  IOException </throws>
        </member>
        <member name="M:Lucene.Net.Store.SimpleFSDirectory.#ctor(System.IO.FileInfo)">
            <summary>Create a new SimpleFSDirectory for the named location and the default lock factory.
            
            </summary>
            <param name="path">the path of the directory
            </param>
            <throws>  IOException </throws>
        </member>
        <member name="M:Lucene.Net.Store.SimpleFSDirectory.#ctor">
            <deprecated> 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Store.SimpleFSDirectory.#ctor(System.IO.DirectoryInfo)">
            <summary>Create a new SimpleFSDirectory for the named location and the default lock factory.
            
            </summary>
            <param name="path">the path of the directory
            </param>
            <throws>  IOException </throws>
        </member>
        <member name="M:Lucene.Net.Store.SimpleFSDirectory.CreateOutput(System.String)">
            <summary>Creates an IndexOutput for the file with the given name. </summary>
        </member>
        <member name="M:Lucene.Net.Store.SimpleFSDirectory.OpenInput(System.String,System.Int32)">
            <summary>Creates an IndexInput for the file with the given name. </summary>
        </member>
        <member name="M:Lucene.Net.Store.SimpleFSDirectory.SimpleFSIndexInput.#ctor(System.IO.FileInfo)">
            <deprecated> Please use ctor taking chunkSize 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Store.SimpleFSDirectory.SimpleFSIndexInput.#ctor(System.IO.FileInfo,System.Int32)">
            <deprecated> Please use ctor taking chunkSize 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Store.SimpleFSDirectory.SimpleFSIndexInput.ReadInternal(System.Byte[],System.Int32,System.Int32)">
            <summary>IndexInput methods </summary>
        </member>
        <member name="M:Lucene.Net.Store.SimpleFSDirectory.SimpleFSIndexInput.IsFDValid">
            <summary>Method used for testing. Returns true if the underlying
            file descriptor is valid.
            </summary>
        </member>
        <member name="T:Lucene.Net.Store.BufferedIndexOutput">
            <summary>Base implementation class for buffered {@link IndexOutput}. </summary>
        </member>
        <member name="T:Lucene.Net.Store.IndexOutput">
            <summary>Abstract base class for output to a file in a Directory.  A random-access
            output stream.  Used for all Lucene index output operations.
            </summary>
            <seealso cref="T:Lucene.Net.Store.Directory">
            </seealso>
            <seealso cref="T:Lucene.Net.Store.IndexInput">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Store.IndexOutput.WriteByte(System.Byte)">
            <summary>Writes a single byte.</summary>
            <seealso cref="M:Lucene.Net.Store.IndexInput.ReadByte">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Store.IndexOutput.WriteBytes(System.Byte[],System.Int32)">
            <summary>Writes an array of bytes.</summary>
            <param name="b">the bytes to write
            </param>
            <param name="length">the number of bytes to write
            </param>
            <seealso cref="M:Lucene.Net.Store.IndexInput.ReadBytes(System.Byte[],System.Int32,System.Int32)">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Store.IndexOutput.WriteBytes(System.Byte[],System.Int32,System.Int32)">
            <summary>Writes an array of bytes.</summary>
            <param name="b">the bytes to write
            </param>
            <param name="offset">the offset in the byte array
            </param>
            <param name="length">the number of bytes to write
            </param>
            <seealso cref="M:Lucene.Net.Store.IndexInput.ReadBytes(System.Byte[],System.Int32,System.Int32)">
            </seealso>
        </member>
        <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="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.IndexOutput.WriteLong(System.Int64)">
            <summary>Writes a long as eight bytes.</summary>
            <seealso cref="M:Lucene.Net.Store.IndexInput.ReadLong">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Store.IndexOutput.WriteVLong(System.Int64)">
            <summary>Writes an long in a variable-length format.  Writes between one and five
            bytes.  Smaller values take fewer bytes.  Negative numbers are not
            supported.
            </summary>
            <seealso cref="M:Lucene.Net.Store.IndexInput.ReadVLong">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Store.IndexOutput.WriteString(System.String)">
            <summary>Writes a string.</summary>
            <seealso cref="M:Lucene.Net.Store.IndexInput.ReadString">
            </seealso>
        </member>
        <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="s">the source of the characters
            </param>
            <param name="start">the first character in the sequence
            </param>
            <param name="length">the number of characters in the sequence
            </param>
            <deprecated> -- please pre-convert to utf8 bytes
            instead or use {@link #writeString}
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Store.IndexOutput.WriteChars(System.Char[],System.Int32,System.Int32)">
            <summary>Writes a sub sequence of characters from char[] as
            the old format (modified UTF-8 encoded bytes).
            </summary>
            <param name="s">the source of the characters
            </param>
            <param name="start">the first character in the sequence
            </param>
            <param name="length">the number of characters in the sequence
            </param>
            <deprecated> -- please pre-convert to utf8 bytes instead or use {@link #writeString}
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Store.IndexOutput.CopyBytes(Lucene.Net.Store.IndexInput,System.Int64)">
            <summary>Copy numBytes bytes from input to ourself. </summary>
        </member>
        <member name="M:Lucene.Net.Store.IndexOutput.Flush">
            <summary>Forces any buffered output to be written. </summary>
        </member>
        <member name="M:Lucene.Net.Store.IndexOutput.Close">
            <summary>Closes this stream to further operations. </summary>
        </member>
        <member name="M:Lucene.Net.Store.IndexOutput.GetFilePointer">
            <summary>Returns the current position in this file, where the next write will
            occur.
            </summary>
            <seealso cref="M:Lucene.Net.Store.IndexOutput.Seek(System.Int64)">
            </seealso>
        </member>
        <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="M:Lucene.Net.Store.IndexOutput.Length">
            <summary>The number of bytes in the file. </summary>
        </member>
        <member name="M:Lucene.Net.Store.IndexOutput.SetLength(System.Int64)">
            <summary>Set the file length. By default, this method does
            nothing (it's optional for a Directory to implement
            it).  But, certain Directory implementations (for
            </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="M:Lucene.Net.Store.BufferedIndexOutput.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.BufferedIndexOutput.WriteBytes(System.Byte[],System.Int32,System.Int32)">
            <summary>Writes an array of bytes.</summary>
            <param name="b">the bytes to write
            </param>
            <param name="length">the number of bytes to write
            </param>
            <seealso cref="M:Lucene.Net.Store.IndexInput.ReadBytes(System.Byte[],System.Int32,System.Int32)">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Store.BufferedIndexOutput.Flush">
            <summary>Forces any buffered output to be written. </summary>
        </member>
        <member name="M:Lucene.Net.Store.BufferedIndexOutput.FlushBuffer(System.Byte[],System.Int32)">
            <summary>Expert: implements buffer write.  Writes bytes at the current position in
            the output.
            </summary>
            <param name="b">the bytes to write
            </param>
            <param name="len">the number of bytes to write
            </param>
        </member>
        <member name="M:Lucene.Net.Store.BufferedIndexOutput.FlushBuffer(System.Byte[],System.Int32,System.Int32)">
            <summary>Expert: implements buffer write.  Writes bytes at the current position in
            the output.
            </summary>
            <param name="b">the bytes to write
            </param>
            <param name="offset">the offset in the byte array
            </param>
            <param name="len">the number of bytes to write
            </param>
        </member>
        <member name="M:Lucene.Net.Store.BufferedIndexOutput.Close">
            <summary>Closes this stream to further operations. </summary>
        </member>
        <member name="M:Lucene.Net.Store.BufferedIndexOutput.GetFilePointer">
            <summary>Returns the current position in this file, where the next write will
            occur.
            </summary>
            <seealso cref="M:Lucene.Net.Store.BufferedIndexOutput.Seek(System.Int64)">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Store.BufferedIndexOutput.Seek(System.Int64)">
            <summary>Sets current position in this file, where the next write will occur.</summary>
            <seealso cref="M:Lucene.Net.Store.BufferedIndexOutput.GetFilePointer">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Store.BufferedIndexOutput.Length">
            <summary>The number of bytes in the file. </summary>
        </member>
        <member name="M:Lucene.Net.Store.SimpleFSDirectory.SimpleFSIndexOutput.FlushBuffer(System.Byte[],System.Int32,System.Int32)">
            <summary>output methods: </summary>
        </member>
        <member name="M:Lucene.Net.Store.SimpleFSDirectory.SimpleFSIndexOutput.Seek(System.Int64)">
            <summary>Random-access methods </summary>
        </member>
        <member name="M:Lucene.Net.Store.FSDirectory.FSIndexInput.#ctor(System.IO.FileInfo)">
            <deprecated> 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Store.FSDirectory.FSIndexInput.#ctor(System.IO.FileInfo,System.Int32)">
            <deprecated> 
            </deprecated>
        </member>
        <member name="T:Lucene.Net.Store.FSDirectory.FSIndexInput.Descriptor">
            <deprecated> 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Store.FSDirectory.FSIndexInput.Descriptor.#ctor(System.IO.FileInfo,System.IO.FileAccess)">
            <deprecated> 
            </deprecated>
        </member>
        <member name="T:Lucene.Net.Store.FSDirectory.FSIndexOutput">
            <deprecated> Use SimpleFSDirectory.SimpleFSIndexOutput instead 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Store.FSDirectory.FSIndexOutput.#ctor(System.IO.FileInfo)">
            <deprecated> 
            </deprecated>
        </member>
        <member name="T:Lucene.Net.Store.LockVerifyServer">
            <summary> Simple standalone server that must be running when you
            use {@link VerifyingLockFactory}.  This server simply
            verifies at most one process holds the lock at a time.
            Run without any args to see usage.
            
            </summary>
            <seealso cref="T:Lucene.Net.Store.VerifyingLockFactory">
            </seealso>
            <seealso cref="T:Lucene.Net.Store.LockStressTest">
            </seealso>
        </member>
        <member name="T:Lucene.Net.Search.SpanFilterResult">
            <summary>  The results of a SpanQueryFilter.  Wraps the BitSet and the position information from the SpanQuery
            
            <p/>
            NOTE: This API is still experimental and subject to change. 
            
            
            </summary>
        </member>
        <member name="F:Lucene.Net.Search.SpanFilterResult.bits">
            <deprecated> 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.SpanFilterResult.#ctor(System.Collections.BitArray,System.Collections.IList)">
            <summary> </summary>
            <param name="bits">The bits for the Filter
            </param>
            <param name="positions">A List of {@link Lucene.Net.Search.SpanFilterResult.PositionInfo} objects
            </param>
            <deprecated> Use {@link #SpanFilterResult(DocIdSet, List)} instead
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.SpanFilterResult.#ctor(Lucene.Net.Search.DocIdSet,System.Collections.IList)">
            <summary> </summary>
            <param name="docIdSet">The DocIdSet for the Filter
            </param>
            <param name="positions">A List of {@link Lucene.Net.Search.SpanFilterResult.PositionInfo} objects
            </param>
        </member>
        <member name="M:Lucene.Net.Search.SpanFilterResult.GetPositions">
            <summary> The first entry in the array corresponds to the first "on" bit.
            Entries are increasing by document order
            </summary>
            <returns> A List of PositionInfo objects
            </returns>
        </member>
        <member name="M:Lucene.Net.Search.SpanFilterResult.GetBits">
            <deprecated> Use {@link #GetDocIdSet()}
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.SpanFilterResult.GetDocIdSet">
            <summary>Returns the docIdSet </summary>
        </member>
        <member name="M:Lucene.Net.Search.SpanFilterResult.PositionInfo.GetPositions">
            <summary> </summary>
            <returns> A List of {@link Lucene.Net.Search.SpanFilterResult.StartEnd} objects
            </returns>
        </member>
        <member name="M:Lucene.Net.Search.SpanFilterResult.StartEnd.GetEnd">
            <summary> </summary>
            <returns> The end position of this match
            </returns>
        </member>
        <member name="M:Lucene.Net.Search.SpanFilterResult.StartEnd.GetStart">
            <summary> The Start position</summary>
            <returns> The start position of this match
            </returns>
        </member>
        <member name="T:Lucene.Net.Search.MultiSearcher">
            <summary>Implements search over a set of <code>Searchables</code>.
            
            <p/>Applications usually need only call the inherited {@link #Search(Query)}
            or {@link #Search(Query,Filter)} methods.
            </summary>
        </member>
        <member name="T:Lucene.Net.Search.Searcher">
            <summary> An abstract base class for search implementations. Implements the main search
            methods.
            
            <p/>
            Note that you can only access hits from a Searcher as long as it is not yet
            closed, otherwise an IOException will be thrown.
            </summary>
        </member>
        <member name="T:Lucene.Net.Search.Searchable">
            <summary> The interface for search implementations.
            
            <p/>
            Searchable is the abstract network protocol for searching. Implementations
            provide search over a single index, over multiple indices, and over indices
            on remote servers.
            
            <p/>
            Queries, filters and sort criteria are designed to be compact so that they
            may be efficiently passed to a remote index, with only the top-scoring hits
            being returned, rather than every matching hit.
            
            <b>NOTE:</b> this interface is kept public for convenience. Since it is not
            expected to be implemented directly, it may be changed unexpectedly between
            releases.
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.Searchable.Search(Lucene.Net.Search.Weight,Lucene.Net.Search.Filter,Lucene.Net.Search.HitCollector)">
            <summary>Lower-level search API.
            
            <p/>{@link HitCollector#Collect(int,float)} is called for every non-zero
            scoring document.
            <br/>HitCollector-based access to remote indexes is discouraged.
            
            <p/>Applications should only use this if they need <i>all</i> of the
            matching documents.  The high-level search API ({@link
            Searcher#Search(Query)}) is usually more efficient, as it skips
            non-high-scoring hits.
            
            </summary>
            <param name="weight">to match documents
            </param>
            <param name="filter">if non-null, used to permit documents to be collected.
            </param>
            <param name="results">to receive hits
            </param>
            <throws>  BooleanQuery.TooManyClauses </throws>
            <deprecated> use {@link #Search(Weight, Filter, Collector)} instead.
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.Searchable.Search(Lucene.Net.Search.Weight,Lucene.Net.Search.Filter,Lucene.Net.Search.Collector)">
            <summary> Lower-level search API.
            
            <p/>
            {@link Collector#Collect(int)} is called for every document. <br/>
            Collector-based access to remote indexes is discouraged.
            
            <p/>
            Applications should only use this if they need <i>all</i> of the matching
            documents. The high-level search API ({@link Searcher#Search(Query)}) is
            usually more efficient, as it skips non-high-scoring hits.
            
            </summary>
            <param name="weight">to match documents
            </param>
            <param name="filter">if non-null, used to permit documents to be collected.
            </param>
            <param name="collector">to receive hits
            </param>
            <throws>  BooleanQuery.TooManyClauses </throws>
        </member>
        <member name="M:Lucene.Net.Search.Searchable.Close">
            <summary>Frees resources associated with this Searcher.
            Be careful not to call this method while you are still using objects
            like {@link Hits}.
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.Searchable.DocFreq(Lucene.Net.Index.Term)">
            <summary>Expert: Returns the number of documents containing <code>term</code>.
            Called by search code to compute term weights.
            </summary>
            <seealso cref="M:Lucene.Net.Index.IndexReader.DocFreq(Lucene.Net.Index.Term)">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Search.Searchable.DocFreqs(Lucene.Net.Index.Term[])">
            <summary>Expert: For each term in the terms array, calculates the number of
            documents containing <code>term</code>. Returns an array with these
            document frequencies. Used to minimize number of remote calls.
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.Searchable.MaxDoc">
            <summary>Expert: Returns one greater than the largest possible document number.
            Called by search code to compute term weights.
            </summary>
            <seealso cref="M:Lucene.Net.Index.IndexReader.MaxDoc">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Search.Searchable.Search(Lucene.Net.Search.Weight,Lucene.Net.Search.Filter,System.Int32)">
            <summary>Expert: Low-level search implementation.  Finds the top <code>n</code>
            hits for <code>query</code>, applying <code>filter</code> if non-null.
            
            <p/>Called by {@link Hits}.
            
            <p/>Applications should usually call {@link Searcher#Search(Query)} or
            {@link Searcher#Search(Query,Filter)} instead.
            </summary>
            <throws>  BooleanQuery.TooManyClauses </throws>
        </member>
        <member name="M:Lucene.Net.Search.Searchable.Doc(System.Int32)">
            <summary>Expert: Returns the stored fields of document <code>i</code>.
            Called by {@link HitCollector} implementations.
            </summary>
            <seealso cref="M:Lucene.Net.Index.IndexReader.Document(System.Int32)">
            </seealso>
            <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.Search.Searchable.Doc(System.Int32,Lucene.Net.Documents.FieldSelector)">
            <summary> Get the {@link Lucene.Net.Documents.Document} at the <code>n</code><sup>th</sup> position. The {@link Lucene.Net.Documents.FieldSelector}
            may be used to determine what {@link Lucene.Net.Documents.Field}s to load and how they should be loaded.
            
            <b>NOTE:</b> If the underlying Reader (more specifically, the underlying <code>FieldsReader</code>) is closed before the lazy {@link Lucene.Net.Documents.Field} is
            loaded an exception may be thrown.  If you want the value of a lazy {@link Lucene.Net.Documents.Field} to be available after closing you must
            explicitly load it or fetch the Document again with a new loader.
            
            
            </summary>
            <param name="n">Get the document at the <code>n</code><sup>th</sup> position
            </param>
            <param name="fieldSelector">The {@link Lucene.Net.Documents.FieldSelector} to use to determine what Fields should be loaded on the Document.  May be null, in which case all Fields will be loaded.
            </param>
            <returns> The stored fields of the {@link Lucene.Net.Documents.Document} at the nth position
            </returns>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  IOException if there is a low-level IO error </throws>
            <summary> 
            </summary>
            <seealso cref="M:Lucene.Net.Index.IndexReader.Document(System.Int32,Lucene.Net.Documents.FieldSelector)">
            </seealso>
            <seealso cref="T:Lucene.Net.Documents.Fieldable">
            </seealso>
            <seealso cref="T:Lucene.Net.Documents.FieldSelector">
            </seealso>
            <seealso cref="T:Lucene.Net.Documents.SetBasedFieldSelector">
            </seealso>
            <seealso cref="T:Lucene.Net.Documents.LoadFirstFieldSelector">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Search.Searchable.Rewrite(Lucene.Net.Search.Query)">
            <summary>Expert: called to re-write queries into primitive queries.</summary>
            <throws>  BooleanQuery.TooManyClauses </throws>
        </member>
        <member name="M:Lucene.Net.Search.Searchable.Explain(Lucene.Net.Search.Weight,System.Int32)">
            <summary>Expert: low-level implementation method
            Returns an Explanation that describes how <code>doc</code> scored against
            <code>weight</code>.
            
            <p/>This is intended to be used in developing Similarity implementations,
            and, for good performance, should not be displayed with every hit.
            Computing an explanation is as expensive as executing the query over the
            entire index.
            <p/>Applications should call {@link Searcher#Explain(Query, int)}.
            </summary>
            <throws>  BooleanQuery.TooManyClauses </throws>
        </member>
        <member name="M:Lucene.Net.Search.Searchable.Search(Lucene.Net.Search.Weight,Lucene.Net.Search.Filter,System.Int32,Lucene.Net.Search.Sort)">
            <summary>Expert: Low-level search implementation with arbitrary sorting.  Finds
            the top <code>n</code> hits for <code>query</code>, applying
            <code>filter</code> if non-null, and sorting the hits by the criteria in
            <code>sort</code>.
            
            <p/>Applications should usually call
            {@link Searcher#Search(Query,Filter,int,Sort)} instead.
            
            </summary>
            <throws>  BooleanQuery.TooManyClauses </throws>
        </member>
        <member name="M:Lucene.Net.Search.Searcher.Search(Lucene.Net.Search.Query)">
            <summary>Returns the documents matching <code>query</code>. </summary>
            <throws>  BooleanQuery.TooManyClauses </throws>
            <deprecated> Hits will be removed in Lucene 3.0. Use
            {@link #Search(Query, Filter, int)} instead.
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.Searcher.Search(Lucene.Net.Search.Query,Lucene.Net.Search.Filter)">
            <summary>Returns the documents matching <code>query</code> and
            <code>filter</code>.
            </summary>
            <throws>  BooleanQuery.TooManyClauses </throws>
            <deprecated> Hits will be removed in Lucene 3.0. Use
            {@link #Search(Query, Filter, int)} instead.
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.Searcher.Search(Lucene.Net.Search.Query,Lucene.Net.Search.Sort)">
            <summary>Returns documents matching <code>query</code> sorted by
            <code>sort</code>.
            </summary>
            <throws>  BooleanQuery.TooManyClauses </throws>
            <deprecated> Hits will be removed in Lucene 3.0. Use 
            {@link #Search(Query, Filter, int, Sort)} instead.
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.Searcher.Search(Lucene.Net.Search.Query,Lucene.Net.Search.Filter,Lucene.Net.Search.Sort)">
            <summary>Returns documents matching <code>query</code> and <code>filter</code>,
            sorted by <code>sort</code>.
            </summary>
            <throws>  BooleanQuery.TooManyClauses </throws>
            <deprecated> Hits will be removed in Lucene 3.0. Use 
            {@link #Search(Query, Filter, int, Sort)} instead.
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.Searcher.Search(Lucene.Net.Search.Query,Lucene.Net.Search.Filter,System.Int32,Lucene.Net.Search.Sort)">
            <summary>Search implementation with arbitrary sorting.  Finds
            the top <code>n</code> hits for <code>query</code>, applying
            <code>filter</code> if non-null, and sorting the hits by the criteria in
            <code>sort</code>.
            
            <p/>NOTE: this does not compute scores by default; use
            {@link IndexSearcher#setDefaultFieldSortScoring} to enable scoring.
            
            </summary>
            <throws>  BooleanQuery.TooManyClauses </throws>
        </member>
        <member name="M:Lucene.Net.Search.Searcher.Search(Lucene.Net.Search.Query,Lucene.Net.Search.HitCollector)">
            <summary>Lower-level search API.
            
            <p/>{@link HitCollector#Collect(int,float)} is called for every matching
            document.
            
            <p/>Applications should only use this if they need <i>all</i> of the
            matching documents.  The high-level search API ({@link
            Searcher#Search(Query)}) is usually more efficient, as it skips
            non-high-scoring hits.
            <p/>Note: The <code>score</code> passed to this method is a raw score.
            In other words, the score will not necessarily be a float whose value is
            between 0 and 1.
            </summary>
            <throws>  BooleanQuery.TooManyClauses </throws>
            <deprecated> use {@link #Search(Query, Collector)} instead.
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.Searcher.Search(Lucene.Net.Search.Query,Lucene.Net.Search.Collector)">
            <summary>Lower-level search API.
            
            <p/>{@link Collector#Collect(int)} is called for every matching document.
            
            <p/>Applications should only use this if they need <i>all</i> of the matching
            documents. The high-level search API ({@link Searcher#Search(Query, int)}
            ) is usually more efficient, as it skips non-high-scoring hits.
            <p/>Note: The <code>score</code> passed to this method is a raw score.
            In other words, the score will not necessarily be a float whose value is
            between 0 and 1.
            </summary>
            <throws>  BooleanQuery.TooManyClauses </throws>
        </member>
        <member name="M:Lucene.Net.Search.Searcher.Search(Lucene.Net.Search.Query,Lucene.Net.Search.Filter,Lucene.Net.Search.HitCollector)">
            <summary>Lower-level search API.
            
            <p/>{@link HitCollector#Collect(int,float)} is called for every matching
            document.
            <br/>HitCollector-based access to remote indexes is discouraged.
            
            <p/>Applications should only use this if they need <i>all</i> of the
            matching documents.  The high-level search API ({@link
            Searcher#Search(Query, Filter, int)}) is usually more efficient, as it skips
            non-high-scoring hits.
            
            </summary>
            <param name="query">to match documents
            </param>
            <param name="filter">if non-null, used to permit documents to be collected.
            </param>
            <param name="results">to receive hits
            </param>
            <throws>  BooleanQuery.TooManyClauses </throws>
            <deprecated> use {@link #Search(Query, Filter, Collector)} instead.
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.Searcher.Search(Lucene.Net.Search.Query,Lucene.Net.Search.Filter,Lucene.Net.Search.Collector)">
            <summary>Lower-level search API.
            
            <p/>{@link Collector#Collect(int)} is called for every matching
            document.
            <br/>Collector-based access to remote indexes is discouraged.
            
            <p/>Applications should only use this if they need <i>all</i> of the
            matching documents.  The high-level search API ({@link
            Searcher#Search(Query, Filter, int)}) is usually more efficient, as it skips
            non-high-scoring hits.
            
            </summary>
            <param name="query">to match documents
            </param>
            <param name="filter">if non-null, used to permit documents to be collected.
            </param>
            <param name="results">to receive hits
            </param>
            <throws>  BooleanQuery.TooManyClauses </throws>
        </member>
        <member name="M:Lucene.Net.Search.Searcher.Search(Lucene.Net.Search.Query,Lucene.Net.Search.Filter,System.Int32)">
            <summary>Finds the top <code>n</code>
            hits for <code>query</code>, applying <code>filter</code> if non-null.
            
            </summary>
            <throws>  BooleanQuery.TooManyClauses </throws>
        </member>
        <member name="M:Lucene.Net.Search.Searcher.Search(Lucene.Net.Search.Query,System.Int32)">
            <summary>Finds the top <code>n</code>
            hits for <code>query</code>.
            
            </summary>
            <throws>  BooleanQuery.TooManyClauses </throws>
        </member>
        <member name="M:Lucene.Net.Search.Searcher.Explain(Lucene.Net.Search.Query,System.Int32)">
            <summary>Returns an Explanation that describes how <code>doc</code> scored against
            <code>query</code>.
            
            <p/>This is intended to be used in developing Similarity implementations,
            and, for good performance, should not be displayed with every hit.
            Computing an explanation is as expensive as executing the query over the
            entire index.
            </summary>
        </member>
        <member name="F:Lucene.Net.Search.Searcher.similarity">
            <summary>The Similarity implementation used by this searcher. </summary>
        </member>
        <member name="M:Lucene.Net.Search.Searcher.SetSimilarity(Lucene.Net.Search.Similarity)">
            <summary>Expert: Set the Similarity implementation used by this Searcher.
            
            </summary>
            <seealso cref="M:Lucene.Net.Search.Similarity.SetDefault(Lucene.Net.Search.Similarity)">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Search.Searcher.GetSimilarity">
            <summary>Expert: Return the Similarity implementation used by this Searcher.
            
            <p/>This defaults to the current value of {@link Similarity#GetDefault()}.
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.Searcher.CreateWeight(Lucene.Net.Search.Query)">
            <summary> creates a weight for <code>query</code></summary>
            <returns> new weight
            </returns>
        </member>
        <member name="M:Lucene.Net.Search.Searcher.Search(Lucene.Net.Search.Weight,Lucene.Net.Search.Filter,Lucene.Net.Search.HitCollector)">
            <deprecated> use {@link #Search(Weight, Filter, Collector)} instead.
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.MultiSearcher.#ctor(Lucene.Net.Search.Searchable[])">
            <summary>Creates a searcher which searches <i>searchers</i>. </summary>
        </member>
        <member name="M:Lucene.Net.Search.MultiSearcher.GetSearchables">
            <summary>Return the array of {@link Searchable}s this searches. </summary>
        </member>
        <member name="M:Lucene.Net.Search.MultiSearcher.Dispose">
            <summary>
            .NET
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.MultiSearcher.SubSearcher(System.Int32)">
            <summary>Returns index of the searcher for document <code>n</code> in the array
            used to construct this searcher. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.MultiSearcher.SubDoc(System.Int32)">
            <summary>Returns the document number of document <code>n</code> within its
            sub-index. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.MultiSearcher.CreateWeight(Lucene.Net.Search.Query)">
            <summary> Create weight in multiple index scenario.
            
            Distributed query processing is done in the following steps:
            1. rewrite query
            2. extract necessary terms
            3. collect dfs for these terms from the Searchables
            4. create query weight using aggregate dfs.
            5. distribute that weight to Searchables
            6. merge results
            
            Steps 1-4 are done here, 5+6 in the search() methods
            
            </summary>
            <returns> rewritten queries
            </returns>
        </member>
        <member name="T:Lucene.Net.Search.MultiSearcher.CachedDfSource">
            <summary> Document Frequency cache acting as a Dummy-Searcher. This class is no
            full-fledged Searcher, but only supports the methods necessary to
            initialize Weights.
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.MultiSearcher.CachedDfSource.Dispose">
            <summary>
            .NET
            </summary>
        </member>
        <member name="T:Lucene.Net.Search.Hit">
            <summary> Wrapper used by {@link HitIterator} to provide a lazily loaded hit
            from {@link Hits}.
            
            </summary>
            <deprecated> Use {@link TopScoreDocCollector} and {@link TopDocs} instead. Hits will be removed in Lucene 3.0.
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.Hit.#ctor(Lucene.Net.Search.Hits,System.Int32)">
            <summary> Constructed from {@link HitIterator}</summary>
            <param name="hits">Hits returned from a search
            </param>
            <param name="hitNumber">Hit index in Hits
            </param>
        </member>
        <member name="M:Lucene.Net.Search.Hit.GetDocument">
            <summary> Returns document for this hit.
            
            </summary>
            <seealso cref="M:Lucene.Net.Search.Hits.Doc(System.Int32)">
            </seealso>
            <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.Search.Hit.GetScore">
            <summary> Returns score for this hit.
            
            </summary>
            <seealso cref="M:Lucene.Net.Search.Hits.Score(System.Int32)">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Search.Hit.GetId">
            <summary> Returns id for this hit.
            
            </summary>
            <seealso cref="M:Lucene.Net.Search.Hits.Id(System.Int32)">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Search.Hit.GetBoost">
            <summary> Returns the boost factor for this hit on any field of the underlying document.
            
            </summary>
            <seealso cref="M:Lucene.Net.Documents.Document.GetBoost">
            </seealso>
            <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.Search.Hit.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>
            <seealso cref="M:Lucene.Net.Documents.Document.Get(System.String)">
            </seealso>
            <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.Search.Hit.ToString">
            <summary> Prints the parameters to be used to discover the promised result.</summary>
        </member>
        <!-- Badly formed XML comment ignored for member "T:Lucene.Net.Search.Function.CustomScoreProvider" -->
        <member name="M:Lucene.Net.Search.Function.CustomScoreProvider.#ctor(Lucene.Net.Index.IndexReader)">
            <summary>
            Creates a new instance of the provider class for the given IndexReader.
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.Function.CustomScoreProvider.CustomScore(System.Int32,System.Single,System.Single[])">
            <summary>
            * Compute a custom score by the subQuery score and a number of 
            ValueSourceQuery scores.
            <p/> 
            Subclasses can override this method to modify the custom score.  
            <p/>
            If your custom scoring is different than the default herein you 
            should override at least one of the two customScore() methods.
            If the number of ValueSourceQueries is always &lt; 2 it is 
            sufficient to override the other 
            {@link #customScore(int, float, float) customScore()} 
            method, which is simpler. 
            <p/>
            The default computation herein is a multiplication of given scores:
            <pre>
                ModifiedScore = valSrcScore * valSrcScores[0] * valSrcScores[1] * ...
            </pre>
            </summary>
            <param name="doc">id of scored doc</param>
            <param name="subQueryScore">score of that doc by the subQuery</param>
            <param name="valSrcScores">scores of that doc by the ValueSourceQuery</param>
            <returns>custom score</returns>
        </member>
        <!-- Badly formed XML comment ignored for member "M:Lucene.Net.Search.Function.CustomScoreProvider.CustomScore(System.Int32,System.Single,System.Single)" -->
        <member name="M:Lucene.Net.Search.Function.CustomScoreProvider.CustomExplain(System.Int32,Lucene.Net.Search.Explanation,Lucene.Net.Search.Explanation[])">
            <summary>
            Explain the custom score.
            Whenever overriding {@link #customScore(int, float, float[])}, 
            this method should also be overridden to provide the correct explanation
            for the part of the custom scoring.
            </summary>
            <param name="doc">doc being explained</param>
            <param name="subQueryExpl">explanation for the sub-query part</param>
            <param name="valSrcExpls">explanation for the value source part</param>
            <returns>an explanation for the custom score</returns>
        </member>
        <member name="M:Lucene.Net.Search.Function.CustomScoreProvider.CustomExplain(System.Int32,Lucene.Net.Search.Explanation,Lucene.Net.Search.Explanation)">
            <summary>
            Explain the custom score.
            Whenever overriding {@link #customScore(int, float, float)}, 
            this method should also be overridden to provide the correct explanation
            for the part of the custom scoring.
            
            </summary>
            <param name="doc">doc being explained</param>
            <param name="subQueryExpl">explanation for the sub-query part</param>
            <param name="valSrcExpl">explanation for the value source part</param>
            <returns>an explanation for the custom score</returns>
        </member>
        <member name="T:Lucene.Net.Search.FilteredQuery">
            <summary> A query that applies a filter to the results of another query.
            
            <p/>Note: the bits are retrieved from the filter each time this
            query is used in a search - use a CachingWrapperFilter to avoid
            regenerating the bits every time.
            
            <p/>Created: Apr 20, 2004 8:58:29 AM
            
            </summary>
            <since>   1.4
            </since>
            <version>  $Id: FilteredQuery.java 807821 2009-08-25 21:55:49Z mikemccand $
            </version>
            <seealso cref="T:Lucene.Net.Search.CachingWrapperFilter">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Search.FilteredQuery.#ctor(Lucene.Net.Search.Query,Lucene.Net.Search.Filter)">
            <summary> Constructs a new query which applies a filter to the results of the original query.
            Filter.getDocIdSet() will be called every time this query is used in a search.
            </summary>
            <param name="query"> Query to be filtered, cannot be <code>null</code>.
            </param>
            <param name="filter">Filter to apply to query results, cannot be <code>null</code>.
            </param>
        </member>
        <member name="M:Lucene.Net.Search.FilteredQuery.CreateWeight(Lucene.Net.Search.Searcher)">
            <summary> Returns a Weight that applies the filter to the enclosed query's Weight.
            This is accomplished by overriding the Scorer returned by the Weight.
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.FilteredQuery.Rewrite(Lucene.Net.Index.IndexReader)">
            <summary>Rewrites the wrapped query. </summary>
        </member>
        <member name="M:Lucene.Net.Search.FilteredQuery.ToString(System.String)">
            <summary>Prints a user-readable version of this query. </summary>
        </member>
        <member name="M:Lucene.Net.Search.FilteredQuery.Equals(System.Object)">
            <summary>Returns true iff <code>o</code> is equal to this. </summary>
        </member>
        <member name="M:Lucene.Net.Search.FilteredQuery.GetHashCode">
            <summary>Returns a hash code value for this object. </summary>
        </member>
        <member name="T:Lucene.Net.Search.Weight">
            <summary> Expert: Calculate query weights and build query scorers.
            <p/>
            The purpose of {@link Weight} is to ensure searching does not
            modify a {@link Query}, so that a {@link Query} instance can be reused. <br/>
            {@link Searcher} dependent state of the query should reside in the
            {@link Weight}. <br/>
            {@link IndexReader} dependent state should reside in the {@link Scorer}.
            <p/>
            A <code>Weight</code> is used in the following way:
            <ol>
            <li>A <code>Weight</code> is constructed by a top-level query, given a
            <code>Searcher</code> ({@link Query#CreateWeight(Searcher)}).</li>
            <li>The {@link #SumOfSquaredWeights()} method is called on the
            <code>Weight</code> to compute the query normalization factor
            {@link Similarity#QueryNorm(float)} of the query clauses contained in the
            query.</li>
            <li>The query normalization factor is passed to {@link #Normalize(float)}. At
            this point the weighting is complete.</li>
            <li>A <code>Scorer</code> is constructed by {@link #Scorer(IndexReader,boolean,boolean)}.</li>
            </ol>
            
            </summary>
            <since> 2.9
            </since>
        </member>
        <member name="M:Lucene.Net.Search.Weight.Explain(Lucene.Net.Index.IndexReader,System.Int32)">
            <summary> An explanation of the score computation for the named document.
            
            </summary>
            <param name="reader">sub-reader containing the give doc
            </param>
            <param name="doc">
            </param>
            <returns> an Explanation for the score
            </returns>
            <throws>  IOException </throws>
        </member>
        <member name="M:Lucene.Net.Search.Weight.GetQuery">
            <summary>The query that this concerns. </summary>
        </member>
        <member name="M:Lucene.Net.Search.Weight.GetValue">
            <summary>The weight for this query. </summary>
        </member>
        <member name="M:Lucene.Net.Search.Weight.Normalize(System.Single)">
            <summary>Assigns the query normalization factor to this. </summary>
        </member>
        <member name="M:Lucene.Net.Search.Weight.Scorer(Lucene.Net.Index.IndexReader,System.Boolean,System.Boolean)">
            <summary> Returns a {@link Scorer} which scores documents in/out-of order according
            to <code>scoreDocsInOrder</code>.
            <p/>
            <b>NOTE:</b> even if <code>scoreDocsInOrder</code> is false, it is
            recommended to check whether the returned <code>Scorer</code> indeed scores
            documents out of order (i.e., call {@link #ScoresDocsOutOfOrder()}), as
            some <code>Scorer</code> implementations will always return documents
            in-order.<br/>
            <b>NOTE:</b> null can be returned if no documents will be scored by this
            query.
            
            </summary>
            <param name="reader">
            the {@link IndexReader} for which to return the {@link Scorer}.
            </param>
            <param name="scoreDocsInOrder">specifies whether in-order scoring of documents is required. Note
            that if set to false (i.e., out-of-order scoring is required),
            this method can return whatever scoring mode it supports, as every
            in-order scorer is also an out-of-order one. However, an
            out-of-order scorer may not support {@link Scorer#NextDoc()}
            and/or {@link Scorer#Advance(int)}, therefore it is recommended to
            request an in-order scorer if use of these methods is required.
            </param>
            <param name="topScorer">
            if true, {@link Scorer#Score(Collector)} will be called; if false,
            {@link Scorer#NextDoc()} and/or {@link Scorer#Advance(int)} will
            be called.
            </param>
            <returns> a {@link Scorer} which scores documents in/out-of order.
            </returns>
            <throws>  IOException </throws>
        </member>
        <member name="M:Lucene.Net.Search.Weight.SumOfSquaredWeights">
            <summary>The sum of squared weights of contained query clauses. </summary>
        </member>
        <member name="M:Lucene.Net.Search.Weight.ScoresDocsOutOfOrder">
            <summary> Returns true iff this implementation scores docs only out of order. This
            method is used in conjunction with {@link Collector}'s
            {@link Collector#AcceptsDocsOutOfOrder() acceptsDocsOutOfOrder} and
            {@link #Scorer(Lucene.Net.Index.IndexReader, boolean, boolean)} to
            create a matching {@link Scorer} instance for a given {@link Collector}, or
            vice versa.
            <p/>
            <b>NOTE:</b> the default implementation returns <code>false</code>, i.e.
            the <code>Scorer</code> scores documents in-order.
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.FilteredQuery.AnonymousClassWeight.AnonymousClassScorer.Next">
            <deprecated> use {@link #NextDoc()} instead. 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.FilteredQuery.AnonymousClassWeight.AnonymousClassScorer.Doc">
            <deprecated> use {@link #DocID()} instead. 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.FilteredQuery.AnonymousClassWeight.AnonymousClassScorer.SkipTo(System.Int32)">
            <deprecated> use {@link #Advance(int)} instead. 
            </deprecated>
        </member>
        <member name="T:Lucene.Net.Search.FieldDoc">
            <summary> Expert: A ScoreDoc which also contains information about
            how to sort the referenced document.  In addition to the
            document number and score, this object contains an array
            of values for the document from the field(s) used to sort.
            For example, if the sort criteria was to sort by fields
            "a", "b" then "c", the <code>fields</code> object array
            will have three elements, corresponding respectively to
            the term values for the document in fields "a", "b" and "c".
            The class of each element in the array will be either
            Integer, Float or String depending on the type of values
            in the terms of each field.
            
            <p/>Created: Feb 11, 2004 1:23:38 PM
            
            </summary>
            <since>   lucene 1.4
            </since>
            <version>  $Id: FieldDoc.java 773194 2009-05-09 10:36:41Z mikemccand $
            </version>
            <seealso cref="T:Lucene.Net.Search.ScoreDoc">
            </seealso>
            <seealso cref="T:Lucene.Net.Search.TopFieldDocs">
            </seealso>
        </member>
        <member name="T:Lucene.Net.Search.ScoreDoc">
            <summary>Expert: Returned by low-level search implementations.</summary>
            <seealso cref="T:Lucene.Net.Search.TopDocs">
            </seealso>
        </member>
        <member name="F:Lucene.Net.Search.ScoreDoc.score">
            <summary>Expert: The score of this document for the query. </summary>
        </member>
        <member name="F:Lucene.Net.Search.ScoreDoc.doc">
            <summary>Expert: A hit document's number.</summary>
            <seealso cref="M:Lucene.Net.Search.Searcher.Doc(System.Int32)">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Search.ScoreDoc.#ctor(System.Int32,System.Single)">
            <summary>Expert: Constructs a ScoreDoc. </summary>
        </member>
        <member name="F:Lucene.Net.Search.FieldDoc.fields">
            <summary>Expert: The values which are used to sort the referenced document.
            The order of these will match the original sort criteria given by a
            Sort object.  Each Object will be either an Integer, Float or String,
            depending on the type of values in the terms of the original field.
            </summary>
            <seealso cref="T:Lucene.Net.Search.Sort">
            </seealso>
            <seealso cref="M:Lucene.Net.Search.Searcher.Search(Lucene.Net.Search.Query,Lucene.Net.Search.Filter,System.Int32,Lucene.Net.Search.Sort)">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Search.FieldDoc.#ctor(System.Int32,System.Single)">
            <summary>Expert: Creates one of these objects with empty sort information. </summary>
        </member>
        <member name="M:Lucene.Net.Search.FieldDoc.#ctor(System.Int32,System.Single,System.IComparable[])">
            <summary>Expert: Creates one of these objects with the given sort information. </summary>
        </member>
        <member name="T:Lucene.Net.Search.FieldCacheRangeFilter">
            <summary> A range filter built on top of a cached single term field (in {@link FieldCache}).
            
            <p/>FieldCacheRangeFilter builds a single cache for the field the first time it is used.
            Each subsequent FieldCacheRangeFilter on the same field then reuses this cache,
            even if the range itself changes. 
            
            <p/>This means that FieldCacheRangeFilter is much faster (sometimes more than 100x as fast) 
            as building a {@link TermRangeFilter} (or {@link ConstantScoreRangeQuery} on a {@link TermRangeFilter})
            for each query, if using a {@link #newStringRange}. However, if the range never changes it
            is slower (around 2x as slow) than building a CachingWrapperFilter on top of a single TermRangeFilter.
            
            For numeric data types, this filter may be significantly faster than {@link NumericRangeFilter}.
            Furthermore, it does not need the numeric values encoded by {@link NumericField}. But
            it has the problem that it only works with exact one value/document (see below).
            
            <p/>As with all {@link FieldCache} based functionality, FieldCacheRangeFilter is only valid for 
            fields which exact one term for each document (except for {@link #newStringRange}
            where 0 terms are also allowed). Due to a restriction of {@link FieldCache}, for numeric ranges
            all terms that do not have a numeric value, 0 is assumed.
            
            <p/>Thus it works on dates, prices and other single value fields but will not work on
            regular text fields. It is preferable to use a <code>NOT_ANALYZED</code> field to ensure that
            there is only a single term. 
            
            <p/>This class does not have an constructor, use one of the static factory methods available,
            that create a correct instance for different data types supported by {@link FieldCache}.
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.FieldCacheRangeFilter.GetDocIdSet(Lucene.Net.Index.IndexReader)">
            <summary>This method is implemented for each data type </summary>
        </member>
        <member name="M:Lucene.Net.Search.FieldCacheRangeFilter.NewStringRange(System.String,System.String,System.String,System.Boolean,System.Boolean)">
            <summary> Creates a string range query using {@link FieldCache#getStringIndex}. This works with all
            fields containing zero or one term in the field. The range can be half-open by setting one
            of the values to <code>null</code>.
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.FieldCacheRangeFilter.NewByteRange(System.String,System.Byte,System.Byte,System.Boolean,System.Boolean)">
            <summary> Creates a numeric range query using {@link FieldCache#GetBytes(IndexReader,String)}. This works with all
            byte fields containing exactly one numeric term in the field. The range can be half-open by setting one
            of the values to <code>null</code>.
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.FieldCacheRangeFilter.NewByteRange(System.String,Lucene.Net.Search.ByteParser,System.Byte,System.Byte,System.Boolean,System.Boolean)">
            <summary> Creates a numeric range query using {@link FieldCache#GetBytes(IndexReader,String,FieldCache.ByteParser)}. This works with all
            byte fields containing exactly one numeric term in the field. The range can be half-open by setting one
            of the values to <code>null</code>.
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.FieldCacheRangeFilter.NewShortRange(System.String,System.ValueType,System.ValueType,System.Boolean,System.Boolean)">
            <summary> Creates a numeric range query using {@link FieldCache#GetShorts(IndexReader,String)}. This works with all
            short fields containing exactly one numeric term in the field. The range can be half-open by setting one
            of the values to <code>null</code>.
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.FieldCacheRangeFilter.NewShortRange(System.String,Lucene.Net.Search.ShortParser,System.ValueType,System.ValueType,System.Boolean,System.Boolean)">
            <summary> Creates a numeric range query using {@link FieldCache#GetShorts(IndexReader,String,FieldCache.ShortParser)}. This works with all
            short fields containing exactly one numeric term in the field. The range can be half-open by setting one
            of the values to <code>null</code>.
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.FieldCacheRangeFilter.NewIntRange(System.String,System.ValueType,System.ValueType,System.Boolean,System.Boolean)">
            <summary> Creates a numeric range query using {@link FieldCache#GetInts(IndexReader,String)}. This works with all
            int fields containing exactly one numeric term in the field. The range can be half-open by setting one
            of the values to <code>null</code>.
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.FieldCacheRangeFilter.NewIntRange(System.String,Lucene.Net.Search.IntParser,System.ValueType,System.ValueType,System.Boolean,System.Boolean)">
            <summary> Creates a numeric range query using {@link FieldCache#GetInts(IndexReader,String,FieldCache.IntParser)}. This works with all
            int fields containing exactly one numeric term in the field. The range can be half-open by setting one
            of the values to <code>null</code>.
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.FieldCacheRangeFilter.NewLongRange(System.String,System.ValueType,System.ValueType,System.Boolean,System.Boolean)">
            <summary> Creates a numeric range query using {@link FieldCache#GetLongs(IndexReader,String)}. This works with all
            long fields containing exactly one numeric term in the field. The range can be half-open by setting one
            of the values to <code>null</code>.
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.FieldCacheRangeFilter.NewLongRange(System.String,Lucene.Net.Search.LongParser,System.ValueType,System.ValueType,System.Boolean,System.Boolean)">
            <summary> Creates a numeric range query using {@link FieldCache#GetLongs(IndexReader,String,FieldCache.LongParser)}. This works with all
            long fields containing exactly one numeric term in the field. The range can be half-open by setting one
            of the values to <code>null</code>.
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.FieldCacheRangeFilter.NewFloatRange(System.String,System.ValueType,System.ValueType,System.Boolean,System.Boolean)">
            <summary> Creates a numeric range query using {@link FieldCache#GetFloats(IndexReader,String)}. This works with all
            float fields containing exactly one numeric term in the field. The range can be half-open by setting one
            of the values to <code>null</code>.
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.FieldCacheRangeFilter.NewFloatRange(System.String,Lucene.Net.Search.FloatParser,System.ValueType,System.ValueType,System.Boolean,System.Boolean)">
            <summary> Creates a numeric range query using {@link FieldCache#GetFloats(IndexReader,String,FieldCache.FloatParser)}. This works with all
            float fields containing exactly one numeric term in the field. The range can be half-open by setting one
            of the values to <code>null</code>.
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.FieldCacheRangeFilter.NewDoubleRange(System.String,System.ValueType,System.ValueType,System.Boolean,System.Boolean)">
            <summary> Creates a numeric range query using {@link FieldCache#GetDoubles(IndexReader,String)}. This works with all
            double fields containing exactly one numeric term in the field. The range can be half-open by setting one
            of the values to <code>null</code>.
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.FieldCacheRangeFilter.NewDoubleRange(System.String,Lucene.Net.Search.DoubleParser,System.ValueType,System.ValueType,System.Boolean,System.Boolean)">
            <summary> Creates a numeric range query using {@link FieldCache#GetDoubles(IndexReader,String,FieldCache.DoubleParser)}. This works with all
            double fields containing exactly one numeric term in the field. The range can be half-open by setting one
            of the values to <code>null</code>.
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.FieldCacheRangeFilter.FieldCacheDocIdSet.MatchDoc(System.Int32)">
            <summary>this method checks, if a doc is a hit, should throw AIOBE, when position invalid </summary>
        </member>
        <member name="M:Lucene.Net.Search.FieldCacheRangeFilter.FieldCacheDocIdSet.IsCacheable">
            <summary>this DocIdSet is cacheable, if it works solely with FieldCache and no TermDocs </summary>
        </member>
        <member name="M:Lucene.Net.Search.FieldCacheRangeFilter.FieldCacheDocIdSet.AnonymousClassDocIdSetIterator.Next">
            @deprecated use {@link #NextDoc()} instead. 
        </member>
        <member name="M:Lucene.Net.Search.FieldCacheRangeFilter.FieldCacheDocIdSet.AnonymousClassDocIdSetIterator.SkipTo(System.Int32)">
            <deprecated> use {@link #Advance(int)} instead. 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.FieldCacheRangeFilter.FieldCacheDocIdSet.AnonymousClassDocIdSetIterator.Doc">
            <deprecated> use {@link #DocID()} instead. 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.FieldCacheRangeFilter.FieldCacheDocIdSet.AnonymousClassDocIdSetIterator1.Next">
            <deprecated> use {@link #NextDoc()} instead. 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.FieldCacheRangeFilter.FieldCacheDocIdSet.AnonymousClassDocIdSetIterator1.SkipTo(System.Int32)">
            <deprecated> use {@link #Advance(int)} instead. 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.FieldCacheRangeFilter.FieldCacheDocIdSet.AnonymousClassDocIdSetIterator1.Doc">
            <deprecated> use {@link #DocID()} instead. 
            </deprecated>
        </member>
        <member name="T:Lucene.Net.Search.CachingSpanFilter">
            <summary> Wraps another SpanFilter's result and caches it.  The purpose is to allow
            filters to simply filter, and then wrap with this class to add caching.
            </summary>
        </member>
        <member name="T:Lucene.Net.Search.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="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>
        </member>
        <member name="F:Lucene.Net.Search.CachingSpanFilter.cache">
            <summary> A transient Filter cache.</summary>
        </member>
        <member name="M:Lucene.Net.Search.CachingSpanFilter.#ctor(Lucene.Net.Search.SpanFilter)">
            <summary>
            New deletions always result in a cache miss, by default
            ({@link CachingWrapperFilter.DeletesMode#RECACHE}.
            <param name="filter">Filter to cache results of
            </param>
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.CachingSpanFilter.#ctor(Lucene.Net.Search.SpanFilter,Lucene.Net.Search.CachingWrapperFilter.DeletesMode)">
            @param filter Filter to cache results of
            @param deletesMode See {@link CachingWrapperFilter.DeletesMode}
        </member>
        <member name="M:Lucene.Net.Search.CachingSpanFilter.Bits(Lucene.Net.Index.IndexReader)">
            <deprecated> Use {@link #GetDocIdSet(IndexReader)} 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="M:Lucene.Net.Search.CachingWrapperFilter.#ctor(Lucene.Net.Search.Filter)">
            New deletes are ignored by default, which gives higher
            cache hit rate on reopened readers.  Most of the time
            this is safe, because the filter will be AND'd with a
            Query that fully enforces deletions.  If instead you
            need this filter to always enforce deletions, pass
            either {@link DeletesMode#RECACHE} or {@link
            DeletesMode#DYNAMIC}.
            @param filter Filter to cache results of
        </member>
        <member name="M:Lucene.Net.Search.CachingWrapperFilter.#ctor(Lucene.Net.Search.Filter,Lucene.Net.Search.CachingWrapperFilter.DeletesMode)">
             Expert: by default, the cached filter will be shared
             across reopened segments that only had changes to their
             deletions.  
            
             @param filter Filter to cache results of
             @param deletesMode See {@link DeletesMode}
        </member>
        <member name="M:Lucene.Net.Search.CachingWrapperFilter.Bits(Lucene.Net.Index.IndexReader)">
            <deprecated> Use {@link #GetDocIdSet(IndexReader)} instead.
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.CachingWrapperFilter.DocIdSetToCache(Lucene.Net.Search.DocIdSet,Lucene.Net.Index.IndexReader)">
            <summary>Provide the DocIdSet to be cached, using the DocIdSet provided
            by the wrapped Filter.
            This implementation returns the given DocIdSet.
            </summary>
        </member>
        <member name="T:Lucene.Net.Search.CachingWrapperFilter.DeletesMode">
             Expert: Specifies how new deletions against a reopened
             reader should be handled.
            
             <p>The default is IGNORE, which means the cache entry
             will be re-used for a given segment, even when that
             segment has been reopened due to changes in deletions.
             This is a big performance gain, especially with
             near-real-timer readers, since you don't hit a cache
             miss on every reopened reader for prior segments.</p>
            
             <p>However, in some cases this can cause invalid query
             results, allowing deleted documents to be returned.
             This only happens if the main query does not rule out
             deleted documents on its own, such as a toplevel
             ConstantScoreQuery.  To fix this, use RECACHE to
             re-create the cached filter (at a higher per-reopen
             cost, but at faster subsequent search performance), or
             use DYNAMIC to dynamically intersect deleted docs (fast
             reopen time but some hit to search performance).</p>
        </member>
        <member name="T:Lucene.Net.Util.Parameter">
            <summary> A serializable Enum class.</summary>
        </member>
        <member name="M:Lucene.Net.Util.Parameter.Equals(System.Object)">
            <summary> Resolves the deserialized instance to the local reference for accurate
            equals() and == comparisons.
            
            </summary>
            <returns> a reference to Parameter as resolved in the local VM
            </returns>
            <throws>  ObjectStreamException </throws>
        </member>
        <member name="F:Lucene.Net.Search.CachingWrapperFilter.FilterCache.cache">
            A transient Filter cache (package private because of test)
        </member>
        <member name="T:Lucene.Net.Search.FilteredDocIdSet">
            <summary> Abstract decorator class for a DocIdSet implementation
            that provides on-demand filtering/validation
            mechanism on a given DocIdSet.
            
            <p/>
            
            Technically, this same functionality could be achieved
            with ChainedFilter (under contrib/misc), however the
            benefit of this class is it never materializes the full
            bitset for the filter.  Instead, the {@link #match}
            method is invoked on-demand, per docID visited during
            searching.  If you know few docIDs will be visited, and
            the logic behind {@link #match} is relatively costly,
            this may be a better way to filter than ChainedFilter.
            
            </summary>
            <seealso cref="T:Lucene.Net.Search.DocIdSet">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Search.FilteredDocIdSet.#ctor(Lucene.Net.Search.DocIdSet)">
            <summary> Constructor.</summary>
            <param name="innerSet">Underlying DocIdSet
            </param>
        </member>
        <member name="M:Lucene.Net.Search.FilteredDocIdSet.IsCacheable">
            <summary>This DocIdSet implementation is cacheable if the inner set is cacheable. </summary>
        </member>
        <member name="M:Lucene.Net.Search.FilteredDocIdSet.Match(System.Int32)">
            <summary> Validation method to determine whether a docid should be in the result set.</summary>
            <param name="docid">docid to be tested
            </param>
            <returns> true if input docid should be in the result set, false otherwise.
            </returns>
        </member>
        <member name="M:Lucene.Net.Search.FilteredDocIdSet.Iterator">
            <summary> Implementation of the contract to build a DocIdSetIterator.</summary>
            <seealso cref="T:Lucene.Net.Search.DocIdSetIterator">
            </seealso>
            <seealso cref="T:Lucene.Net.Search.FilteredDocIdSetIterator">
            </seealso>
        </member>
        <member name="T:Lucene.Net.Search.FilteredDocIdSetIterator">
            <summary> Abstract decorator class of a DocIdSetIterator
            implementation that provides on-demand filter/validation
            mechanism on an underlying DocIdSetIterator.  See {@link
            FilteredDocIdSet}.
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.FilteredDocIdSetIterator.#ctor(Lucene.Net.Search.DocIdSetIterator)">
            <summary> Constructor.</summary>
            <param name="innerIter">Underlying DocIdSetIterator.
            </param>
        </member>
        <member name="M:Lucene.Net.Search.FilteredDocIdSetIterator.Match(System.Int32)">
            <summary> Validation method to determine whether a docid should be in the result set.</summary>
            <param name="doc">docid to be tested
            </param>
            <returns> true if input docid should be in the result set, false otherwise.
            </returns>
            <seealso cref="M:Lucene.Net.Search.FilteredDocIdSetIterator.#ctor(Lucene.Net.Search.DocIdSetIterator)">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Search.FilteredDocIdSetIterator.Doc">
            <deprecated> use {@link #DocID()} instead. 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.FilteredDocIdSetIterator.Next">
            <deprecated> use {@link #NextDoc()} instead. 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.FilteredDocIdSetIterator.SkipTo(System.Int32)">
            <deprecated> use {@link #Advance(int)} instead. 
            </deprecated>
        </member>
        <member name="T:Lucene.Net.QueryParsers.ParseException">
            <summary> This exception is thrown when parse errors are encountered.
            You can explicitly create objects of this exception type by
            calling the method generateParseException in the generated
            parser.
            
            You can modify this class to customize your error reporting
            mechanisms so long as you retain the public fields.
            </summary>
        </member>
        <member name="M:Lucene.Net.QueryParsers.ParseException.#ctor(Lucene.Net.QueryParsers.Token,System.Int32[][],System.String[])">
            <summary> This constructor is used by the method "generateParseException"
            in the generated parser.  Calling this constructor generates
            a new object of this type with the fields "currentToken",
            "expectedTokenSequences", and "tokenImage" set.  The boolean
            flag "specialConstructor" is also set to true to indicate that
            this constructor was used to create this object.
            This constructor calls its super class with the empty string
            to force the "toString" method of parent class "Throwable" to
            print the error message in the form:
            ParseException: &lt;result of getMessage&gt;
            </summary>
        </member>
        <member name="M:Lucene.Net.QueryParsers.ParseException.#ctor">
            <summary> The following constructors are for use by you for whatever
            purpose you can think of.  Constructing the exception in this
            manner makes the exception behave in the normal way - i.e., as
            documented in the class "Throwable".  The fields "errorToken",
            "expectedTokenSequences", and "tokenImage" do not contain
            relevant information.  The JavaCC generated code does not use
            these constructors.
            </summary>
        </member>
        <member name="M:Lucene.Net.QueryParsers.ParseException.#ctor(System.String)">
            <summary>Constructor with message. </summary>
        </member>
        <member name="M:Lucene.Net.QueryParsers.ParseException.#ctor(System.String,System.Exception)">
            <summary>Constructor with message. </summary>
        </member>
        <member name="F:Lucene.Net.QueryParsers.ParseException.specialConstructor">
            <summary> This variable determines which constructor was used to create
            this object and thereby affects the semantics of the
            "getMessage" method (see below).
            </summary>
        </member>
        <member name="F:Lucene.Net.QueryParsers.ParseException.currentToken">
            <summary> This is the last token that has been consumed successfully.  If
            this object has been created due to a parse error, the token
            followng this token will (therefore) be the first error token.
            </summary>
        </member>
        <member name="F:Lucene.Net.QueryParsers.ParseException.expectedTokenSequences">
            <summary> Each entry in this array is an array of integers.  Each array
            of integers represents a sequence of tokens (by their ordinal
            values) that is expected at this point of the parse.
            </summary>
        </member>
        <member name="F:Lucene.Net.QueryParsers.ParseException.tokenImage">
            <summary> This is a reference to the "tokenImage" array of the generated
            parser within which the parse error occurred.  This array is
            defined in the generated ...Constants interface.
            </summary>
        </member>
        <member name="F:Lucene.Net.QueryParsers.ParseException.eol">
            <summary> The end of line string for this machine.</summary>
        </member>
        <member name="M:Lucene.Net.QueryParsers.ParseException.Add_escapes(System.String)">
            <summary> Used to convert raw characters to their escaped version
            when these raw version cannot be used as part of an ASCII
            string literal.
            </summary>
        </member>
        <member name="P:Lucene.Net.QueryParsers.ParseException.Message">
            <summary> This method has the standard behavior when this object has been
            created using the standard constructors.  Otherwise, it uses
            "currentToken" and "expectedTokenSequences" to generate a parse
            error message and returns it.  If this object has been created
            due to a parse error, and you do not catch it (it gets thrown
            from the parser), then this method is called during the printing
            of the final stack trace, and hence the correct error message
            gets displayed.
            </summary>
        </member>
        <member name="T:Lucene.Net.QueryParsers.CharStream">
            <summary> This interface describes a character stream that maintains line and
            column number positions of the characters.  It also has the capability
            to backup the stream to some extent.  An implementation of this
            interface is used in the TokenManager implementation generated by
            JavaCCParser.
            
            All the methods except backup can be implemented in any fashion. backup
            needs to be implemented correctly for the correct operation of the lexer.
            Rest of the methods are all used to get information like line number,
            column number and the String that constitutes a token and are not used
            by the lexer. Hence their implementation won't affect the generated lexer's
            operation.
            </summary>
        </member>
        <member name="M:Lucene.Net.QueryParsers.CharStream.ReadChar">
            <summary> Returns the next character from the selected input.  The method
            of selecting the input is the responsibility of the class
            implementing this interface.  Can throw any java.io.IOException.
            </summary>
        </member>
        <member name="M:Lucene.Net.QueryParsers.CharStream.GetColumn">
            <summary> Returns the column position of the character last read.</summary>
            <deprecated>
            </deprecated>
            <seealso cref="!:getEndColumn">
            </seealso>
        </member>
        <member name="M:Lucene.Net.QueryParsers.CharStream.GetLine">
            <summary> Returns the line number of the character last read.</summary>
            <deprecated>
            </deprecated>
            <seealso cref="!:getEndLine">
            </seealso>
        </member>
        <member name="M:Lucene.Net.QueryParsers.CharStream.GetEndColumn">
            <summary> Returns the column number of the last character for current token (being
            matched after the last call to BeginTOken).
            </summary>
        </member>
        <member name="M:Lucene.Net.QueryParsers.CharStream.GetEndLine">
            <summary> Returns the line number of the last character for current token (being
            matched after the last call to BeginTOken).
            </summary>
        </member>
        <member name="M:Lucene.Net.QueryParsers.CharStream.GetBeginColumn">
            <summary> Returns the column number of the first character for current token (being
            matched after the last call to BeginTOken).
            </summary>
        </member>
        <member name="M:Lucene.Net.QueryParsers.CharStream.GetBeginLine">
            <summary> Returns the line number of the first character for current token (being
            matched after the last call to BeginTOken).
            </summary>
        </member>
        <member name="M:Lucene.Net.QueryParsers.CharStream.Backup(System.Int32)">
            <summary> Backs up the input stream by amount steps. Lexer calls this method if it
            had already read some characters, but could not use them to match a
            (longer) token. So, they will be used again as the prefix of the next
            token and it is the implemetation's responsibility to do this right.
            </summary>
        </member>
        <member name="M:Lucene.Net.QueryParsers.CharStream.BeginToken">
            <summary> Returns the next character that marks the beginning of the next token.
            All characters must remain in the buffer between two successive calls
            to this method to implement backup correctly.
            </summary>
        </member>
        <member name="M:Lucene.Net.QueryParsers.CharStream.GetImage">
            <summary> Returns a string made up of characters from the marked token beginning
            to the current buffer position. Implementations have the choice of returning
            anything that they want to. For example, for efficiency, one might decide
            to just return null, which is a valid implementation.
            </summary>
        </member>
        <member name="M:Lucene.Net.QueryParsers.CharStream.GetSuffix(System.Int32)">
            <summary> Returns an array of characters that make up the suffix of length 'len' for
            the currently matched token. This is used to build up the matched string
            for use in actions in the case of MORE. A simple and inefficient
            implementation of this is as follows :
            
            {
            String t = GetImage();
            return t.substring(t.length() - len, t.length()).toCharArray();
            }
            </summary>
        </member>
        <member name="M:Lucene.Net.QueryParsers.CharStream.Done">
            <summary> The lexer calls this function to indicate that it is done with the stream
            and hence implementations can free any resources held by this class.
            Again, the body of this function can be just empty and it will not
            affect the lexer's operation.
            </summary>
        </member>
        <member name="T:Lucene.Net.Messages.MessageImpl">
            <summary> Default implementation of Message interface.
            For Native Language Support (NLS), system of software internationalization.
            </summary>
        </member>
        <member name="T:Lucene.Net.Messages.Message">
            <summary> Message Interface for a lazy loading.
            For Native Language Support (NLS), system of software internationalization.
            </summary>
        </member>
        <member name="T:Lucene.Net.Index.KeepOnlyLastCommitDeletionPolicy">
            <summary> This {@link IndexDeletionPolicy} implementation that
            keeps only the most recent commit and immediately removes
            all prior commits after a new commit is done.  This is
            the default deletion policy.
            </summary>
        </member>
        <member name="T:Lucene.Net.Index.IndexDeletionPolicy">
            <summary> <p/>Expert: policy for deletion of stale {@link IndexCommit index commits}. 
            
            <p/>Implement this interface, and pass it to one
            of the {@link IndexWriter} or {@link IndexReader}
            constructors, to customize when older
            {@link IndexCommit point-in-time commits}
            are deleted from the index directory.  The default deletion policy
            is {@link KeepOnlyLastCommitDeletionPolicy}, which always
            removes old commits as soon as a new commit is done (this
            matches the behavior before 2.2).<p/>
            
            <p/>One expected use case for this (and the reason why it
            was first created) is to work around problems with an
            index directory accessed via filesystems like NFS because
            NFS does not provide the "delete on last close" semantics
            that Lucene's "point in time" search normally relies on.
            By implementing a custom deletion policy, such as "a
            commit is only removed once it has been stale for more
            than X minutes", you can give your readers time to
            refresh to the new commit before {@link IndexWriter}
            removes the old commits.  Note that doing so will
            increase the storage requirements of the index.  See <a
            target="top"
            href="http://issues.apache.org/jira/browse/LUCENE-710">LUCENE-710</a>
            for details.<p/>
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexDeletionPolicy.OnInit(System.Collections.IList)">
            <summary> <p/>This is called once when a writer is first
            instantiated to give the policy a chance to remove old
            commit points.<p/>
            
            <p/>The writer locates all index commits present in the 
            index directory and calls this method.  The policy may 
            choose to delete some of the commit points, doing so by
            calling method {@link IndexCommit#delete delete()} 
            of {@link IndexCommit}.<p/>
            
            <p/><u>Note:</u> the last CommitPoint is the most recent one,
            i.e. the "front index state". Be careful not to delete it,
            unless you know for sure what you are doing, and unless 
            you can afford to lose the index content while doing that. 
            
            </summary>
            <param name="commits">List of current 
            {@link IndexCommit point-in-time commits},
            sorted by age (the 0th one is the oldest commit).
            </param>
        </member>
        <member name="M:Lucene.Net.Index.IndexDeletionPolicy.OnCommit(System.Collections.IList)">
            <summary> <p/>This is called each time the writer completed a commit.
            This gives the policy a chance to remove old commit points
            with each commit.<p/>
            
            <p/>The policy may now choose to delete old commit points 
            by calling method {@link IndexCommit#delete delete()} 
            of {@link IndexCommit}.<p/>
            
            <p/>If writer has <code>autoCommit = true</code> then
            this method will in general be called many times during
            one instance of {@link IndexWriter}.  If
            <code>autoCommit = false</code> then this method is
            only called once when {@link IndexWriter#close} is
            called, or not at all if the {@link IndexWriter#abort}
            is called. 
            
            <p/><u>Note:</u> the last CommitPoint is the most recent one,
            i.e. the "front index state". Be careful not to delete it,
            unless you know for sure what you are doing, and unless 
            you can afford to lose the index content while doing that.
            
            </summary>
            <param name="commits">List of {@link IndexCommit},
            sorted by age (the 0th one is the oldest commit).
            </param>
        </member>
        <member name="M:Lucene.Net.Index.KeepOnlyLastCommitDeletionPolicy.OnInit(System.Collections.IList)">
            <summary> Deletes all commits except the most recent one.</summary>
        </member>
        <member name="M:Lucene.Net.Index.KeepOnlyLastCommitDeletionPolicy.OnCommit(System.Collections.IList)">
            <summary> Deletes all commits except the most recent one.</summary>
        </member>
        <member name="T:Lucene.Net.Index.FieldSortedTermVectorMapper">
            <summary> For each Field, store a sorted collection of {@link TermVectorEntry}s
            <p/>
            This is not thread-safe.
            </summary>
        </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>
        <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>
        <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>
        <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>
        <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>
        <member name="M:Lucene.Net.Index.TermVectorMapper.IsIgnoringOffsets">
            <summary> </summary>
            <seealso cref="M:Lucene.Net.Index.TermVectorMapper.IsIgnoringPositions"> Same principal as {@link #IsIgnoringPositions()}, but applied to offsets.  false by default.
            </seealso>
            <returns> false
            </returns>
        </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>
        <member name="M:Lucene.Net.Index.FieldSortedTermVectorMapper.#ctor(System.Collections.Generic.IComparer{System.Object})">
            <summary> </summary>
            <param name="comparator">A Comparator for sorting {@link TermVectorEntry}s
            </param>
        </member>
        <member name="M:Lucene.Net.Index.FieldSortedTermVectorMapper.GetFieldToTerms">
            <summary> Get the mapping between fields and terms, sorted by the comparator
            
            </summary>
            <returns> A map between field names and {@link java.util.SortedSet}s per field.  SortedSet entries are {@link TermVectorEntry}
            </returns>
        </member>
        <member name="T:Lucene.Net.Index.CompoundFileWriter">
            <summary> Combines multiple files into a single compound file.
            The file format:<br/>
            <ul>
            <li>VInt fileCount</li>
            <li>{Directory}
            fileCount entries with the following structure:</li>
            <ul>
            <li>long dataOffset</li>
            <li>String fileName</li>
            </ul>
            <li>{File Data}
            fileCount entries with the raw data of the corresponding file</li>
            </ul>
            
            The fileCount integer indicates how many files are contained in this compound
            file. The {directory} that follows has that many entries. Each directory entry
            contains a long pointer to the start of this file's data section, and a String
            with that file's name.
            
            
            </summary>
            <version>  $Id: CompoundFileWriter.java 690539 2008-08-30 17:33:06Z mikemccand $
            </version>
        </member>
        <member name="M:Lucene.Net.Index.CompoundFileWriter.#ctor(Lucene.Net.Store.Directory,System.String)">
            <summary>Create the compound stream in the specified file. The file name is the
            entire name (no extensions are added).
            </summary>
            <throws>  NullPointerException if <code>dir</code> or <code>name</code> is null </throws>
        </member>
        <member name="M:Lucene.Net.Index.CompoundFileWriter.GetDirectory">
            <summary>Returns the directory of the compound file. </summary>
        </member>
        <member name="M:Lucene.Net.Index.CompoundFileWriter.GetName">
            <summary>Returns the name of the compound file. </summary>
        </member>
        <member name="M:Lucene.Net.Index.CompoundFileWriter.AddFile(System.String)">
            <summary>Add a source stream. <code>file</code> is the string by which the 
            sub-stream will be known in the compound stream.
            
            </summary>
            <throws>  IllegalStateException if this writer is closed </throws>
            <throws>  NullPointerException if <code>file</code> is null </throws>
            <throws>  IllegalArgumentException if a file with the same name </throws>
            <summary>   has been added already
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.CompoundFileWriter.Close">
            <summary>Merge files with the extensions added up to now.
            All files with these extensions are combined sequentially into the
            compound stream. After successful merge, the source files
            are deleted.
            </summary>
            <throws>  IllegalStateException if close() had been called before or </throws>
            <summary>   if no file has been added to this object
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.CompoundFileWriter.CopyFile(Lucene.Net.Index.CompoundFileWriter.FileEntry,Lucene.Net.Store.IndexOutput,System.Byte[])">
            <summary>Copy the contents of the file with specified extension into the
            provided output stream. Use the provided buffer for moving data
            to reduce memory allocation.
            </summary>
        </member>
        <member name="F:Lucene.Net.Index.CompoundFileWriter.FileEntry.file">
            <summary>source file </summary>
        </member>
        <member name="F:Lucene.Net.Index.CompoundFileWriter.FileEntry.directoryOffset">
            <summary>temporary holder for the start of directory entry for this file </summary>
        </member>
        <member name="F:Lucene.Net.Index.CompoundFileWriter.FileEntry.dataOffset">
            <summary>temporary holder for the start of this file's data section </summary>
        </member>
        <member name="T:Lucene.Net.Index.CompoundFileReader">
            <summary> Class for accessing a compound stream.
            This class implements a directory, but is limited to only read operations.
            Directory methods that would normally modify data throw an exception.
            
            
            </summary>
            <version>  $Id: CompoundFileReader.java 673371 2008-07-02 11:57:27Z mikemccand $
            </version>
        </member>
        <member name="M:Lucene.Net.Index.CompoundFileReader.Dispose">
            <summary>
            .NET
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.CompoundFileReader.List">
            <summary>Returns an array of strings, one for each file in the directory. </summary>
        </member>
        <member name="M:Lucene.Net.Index.CompoundFileReader.FileExists(System.String)">
            <summary>Returns true iff a file with the given name exists. </summary>
        </member>
        <member name="M:Lucene.Net.Index.CompoundFileReader.FileModified(System.String)">
            <summary>Returns the time the compound file was last modified. </summary>
        </member>
        <member name="M:Lucene.Net.Index.CompoundFileReader.TouchFile(System.String)">
            <summary>Set the modified time of the compound file to now. </summary>
        </member>
        <member name="M:Lucene.Net.Index.CompoundFileReader.DeleteFile(System.String)">
            <summary>Not implemented</summary>
            <throws>  UnsupportedOperationException  </throws>
        </member>
        <member name="M:Lucene.Net.Index.CompoundFileReader.RenameFile(System.String,System.String)">
            <summary>Not implemented</summary>
            <throws>  UnsupportedOperationException  </throws>
        </member>
        <member name="M:Lucene.Net.Index.CompoundFileReader.FileLength(System.String)">
            <summary>Returns the length of a file in the directory.</summary>
            <throws>  IOException if the file does not exist  </throws>
        </member>
        <member name="M:Lucene.Net.Index.CompoundFileReader.CreateOutput(System.String)">
            <summary>Not implemented</summary>
            <throws>  UnsupportedOperationException  </throws>
        </member>
        <member name="M:Lucene.Net.Index.CompoundFileReader.MakeLock(System.String)">
            <summary>Not implemented</summary>
            <throws>  UnsupportedOperationException  </throws>
        </member>
        <member name="T:Lucene.Net.Index.CompoundFileReader.CSIndexInput">
            <summary>Implementation of an IndexInput that reads from a portion of the
            compound file. The visibility is left as "package" *only* because
            this helps with testing since JUnit test cases in a different class
            can then access package fields of this class.
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.CompoundFileReader.CSIndexInput.ReadInternal(System.Byte[],System.Int32,System.Int32)">
            <summary>Expert: implements buffer refill.  Reads bytes from the current
            position in the input.
            </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>
        </member>
        <member name="M:Lucene.Net.Index.CompoundFileReader.CSIndexInput.SeekInternal(System.Int64)">
            <summary>Expert: implements seek.  Sets current position in this file, where
            the next {@link #ReadInternal(byte[],int,int)} will occur.
            </summary>
            <seealso cref="M:Lucene.Net.Index.CompoundFileReader.CSIndexInput.ReadInternal(System.Byte[],System.Int32,System.Int32)">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Index.CompoundFileReader.CSIndexInput.Close">
            <summary>Closes the stream to further operations. </summary>
        </member>
        <member name="T:Lucene.Net.Analysis.Tokenattributes.PayloadAttributeImpl">
            <summary> The payload of a Token. See also {@link Payload}.</summary>
        </member>
        <member name="T:Lucene.Net.Analysis.Tokenattributes.PayloadAttribute">
            <summary> The payload of a Token. See also {@link Payload}.</summary>
        </member>
        <member name="M:Lucene.Net.Analysis.Tokenattributes.PayloadAttribute.GetPayload">
            <summary> Returns this Token's payload.</summary>
        </member>
        <member name="M:Lucene.Net.Analysis.Tokenattributes.PayloadAttribute.SetPayload(Lucene.Net.Index.Payload)">
            <summary> Sets this Token's payload.</summary>
        </member>
        <member name="M:Lucene.Net.Analysis.Tokenattributes.PayloadAttributeImpl.#ctor">
            <summary> Initialize this attribute with no payload.</summary>
        </member>
        <member name="M:Lucene.Net.Analysis.Tokenattributes.PayloadAttributeImpl.#ctor(Lucene.Net.Index.Payload)">
            <summary> Initialize this attribute with the given payload. </summary>
        </member>
        <member name="M:Lucene.Net.Analysis.Tokenattributes.PayloadAttributeImpl.GetPayload">
            <summary> Returns this Token's payload.</summary>
        </member>
        <member name="M:Lucene.Net.Analysis.Tokenattributes.PayloadAttributeImpl.SetPayload(Lucene.Net.Index.Payload)">
            <summary> Sets this Token's payload.</summary>
        </member>
        <member name="T:Lucene.Net.Analysis.Tokenattributes.OffsetAttribute">
            <summary> The start and end character offset of a Token. </summary>
        </member>
        <member name="M:Lucene.Net.Analysis.Tokenattributes.OffsetAttribute.StartOffset">
            <summary>Returns this Token's starting offset, the position of the first character
            corresponding to this token in the source text.
            Note that the difference between endOffset() and startOffset() may not be
            equal to termText.length(), as the term text may have been altered by a
            stemmer or some other filter. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Analysis.Tokenattributes.OffsetAttribute.SetOffset(System.Int32,System.Int32)">
            <summary>Set the starting and ending offset.
            See StartOffset() and EndOffset()
            </summary>
        </member>
        <member name="M:Lucene.Net.Analysis.Tokenattributes.OffsetAttribute.EndOffset">
            <summary>Returns this Token's ending offset, one greater than the position of the
            last character corresponding to this token in the source text. The length
            of the token in the source text is (endOffset - startOffset). 
            </summary>
        </member>
        <member name="T:Lucene.Net.Analysis.Tokenattributes.FlagsAttributeImpl">
            <summary> This attribute can be used to pass different flags down the tokenizer chain,
            eg from one TokenFilter to another one. 
            </summary>
        </member>
        <member name="T:Lucene.Net.Analysis.Tokenattributes.FlagsAttribute">
            <summary> This attribute can be used to pass different flags down the {@link Tokenizer} chain,
            eg from one TokenFilter to another one. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Analysis.Tokenattributes.FlagsAttribute.GetFlags">
            <summary> EXPERIMENTAL:  While we think this is here to stay, we may want to change it to be a long.
            <p/>
            
            Get the bitset for any bits that have been set.  This is completely distinct from {@link TypeAttribute#Type()}, although they do share similar purposes.
            The flags can be used to encode information about the token for use by other {@link Lucene.Net.Analysis.TokenFilter}s.
            
            
            </summary>
            <returns> The bits
            </returns>
        </member>
        <member name="M:Lucene.Net.Analysis.Tokenattributes.FlagsAttribute.SetFlags(System.Int32)">
            <seealso cref="M:Lucene.Net.Analysis.Tokenattributes.FlagsAttribute.GetFlags">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Analysis.Tokenattributes.FlagsAttributeImpl.GetFlags">
            <summary> EXPERIMENTAL:  While we think this is here to stay, we may want to change it to be a long.
            <p/>
            
            Get the bitset for any bits that have been set.  This is completely distinct from {@link TypeAttribute#Type()}, although they do share similar purposes.
            The flags can be used to encode information about the token for use by other {@link Lucene.Net.Analysis.TokenFilter}s.
            
            
            </summary>
            <returns> The bits
            </returns>
        </member>
        <member name="M:Lucene.Net.Analysis.Tokenattributes.FlagsAttributeImpl.SetFlags(System.Int32)">
            <seealso cref="M:Lucene.Net.Analysis.Tokenattributes.FlagsAttributeImpl.GetFlags">
            </seealso>
        </member>
        <member name="T:Lucene.Net.Util.ReaderUtil">
            <summary> Common util methods for dealing with {@link IndexReader}s.
            
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.ReaderUtil.GatherSubReaders(System.Collections.IList,Lucene.Net.Index.IndexReader)">
            <summary> Gathers sub-readers from reader into a List.
            
            </summary>
            <param name="allSubReaders">
            </param>
            <param name="reader">
            </param>
        </member>
        <member name="M:Lucene.Net.Util.ReaderUtil.SubReader(System.Int32,Lucene.Net.Index.IndexReader)">
            <summary> Returns sub IndexReader that contains the given document id.
            
            </summary>
            <param name="doc">id of document
            </param>
            <param name="reader">parent reader
            </param>
            <returns> sub reader of parent which contains the specified doc id
            </returns>
        </member>
        <member name="M:Lucene.Net.Util.ReaderUtil.SubReader(Lucene.Net.Index.IndexReader,System.Int32)">
            <summary> Returns sub-reader subIndex from reader.
            
            </summary>
            <param name="reader">parent reader
            </param>
            <param name="subIndex">index of desired sub reader
            </param>
            <returns> the subreader at subINdex
            </returns>
        </member>
        <member name="M:Lucene.Net.Util.ReaderUtil.SubIndex(System.Int32,System.Int32[])">
            <summary> Returns index of the searcher/reader for document <code>n</code> in the
            array used to construct this searcher/reader.
            </summary>
        </member>
        <member name="T:Lucene.Net.Search.TopFieldDocCollector">
            <summary>A {@link HitCollector} implementation that collects the top-sorting
            documents, returning them as a {@link TopFieldDocs}.  This is used by {@link
            IndexSearcher} to implement {@link TopFieldDocs}-based search.
            
            <p/>This may be extended, overriding the collect method to, e.g.,
            conditionally invoke <code>super()</code> in order to filter which
            documents are collected.
            
            </summary>
            <deprecated> Please use {@link TopFieldCollector} instead.
            </deprecated>
        </member>
        <member name="T:Lucene.Net.Search.TopDocCollector">
            <summary>A {@link HitCollector} implementation that collects the top-scoring
            documents, returning them as a {@link TopDocs}.  This is used by {@link
            IndexSearcher} to implement {@link TopDocs}-based search.
            
            <p/>This may be extended, overriding the collect method to, e.g.,
            conditionally invoke <code>super()</code> in order to filter which
            documents are collected.
            
            </summary>
            <deprecated> Please use {@link TopScoreDocCollector}
            instead, which has better performance.
            
            </deprecated>
        </member>
        <member name="T:Lucene.Net.Search.HitCollector">
            <summary> Lower-level search API. <br/>
            HitCollectors are primarily meant to be used to implement queries, sorting
            and filtering. See {@link Collector} for a lower level and higher performance
            (on a multi-segment index) API.
            
            </summary>
            <seealso cref="M:Lucene.Net.Search.Searcher.Search(Lucene.Net.Search.Query,Lucene.Net.Search.HitCollector)">
            </seealso>
            <version>  $Id: HitCollector.java 764551 2009-04-13 18:33:56Z mikemccand $
            </version>
            <deprecated> Please use {@link Collector} instead.
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.HitCollector.Collect(System.Int32,System.Single)">
            <summary>Called once for every document matching a query, with the document
            number and its raw score.
            
            <p/>If, for example, an application wished to collect all of the hits for a
            query in a BitSet, then it might:<pre>
            Searcher searcher = new IndexSearcher(indexReader);
            final BitSet bits = new BitSet(indexReader.maxDoc());
            searcher.search(query, new HitCollector() {
            public void collect(int doc, float score) {
            bits.set(doc);
            }
            });
            </pre>
            
            <p/>Note: This is called in an inner search loop.  For good search
            performance, implementations of this method should not call
            {@link Searcher#Doc(int)} or
            {@link Lucene.Net.Index.IndexReader#Document(int)} on every
            document number encountered.  Doing so can slow searches by an order
            of magnitude or more.
            <p/>Note: The <code>score</code> passed to this method is a raw score.
            In other words, the score will not necessarily be a float whose value is
            between 0 and 1.
            </summary>
        </member>
        <member name="F:Lucene.Net.Search.TopDocCollector.totalHits">
            <summary>The total number of hits the collector encountered. </summary>
        </member>
        <member name="F:Lucene.Net.Search.TopDocCollector.hq">
            <summary>The priority queue which holds the top-scoring documents. </summary>
        </member>
        <member name="M:Lucene.Net.Search.TopDocCollector.#ctor(System.Int32)">
            <summary>Construct to collect a given number of hits.</summary>
            <param name="numHits">the maximum number of hits to collect
            </param>
        </member>
        <member name="M:Lucene.Net.Search.TopDocCollector.#ctor(System.Int32,Lucene.Net.Util.PriorityQueue)">
            <deprecated> use TopDocCollector(hq) instead. numHits is not used by this
            constructor. It will be removed in a future release.
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.TopDocCollector.#ctor(Lucene.Net.Util.PriorityQueue)">
            <summary>Constructor to collect the top-scoring documents by using the given PQ.</summary>
            <param name="hq">the PQ to use by this instance.
            </param>
        </member>
        <member name="M:Lucene.Net.Search.TopDocCollector.GetTotalHits">
            <summary>The total number of documents that matched this query. </summary>
        </member>
        <member name="M:Lucene.Net.Search.TopDocCollector.TopDocs">
            <summary>The top-scoring hits. </summary>
        </member>
        <member name="M:Lucene.Net.Search.TopFieldDocCollector.#ctor(Lucene.Net.Index.IndexReader,Lucene.Net.Search.Sort,System.Int32)">
            <summary>Construct to collect a given number of hits.</summary>
            <param name="reader">the index to be searched
            </param>
            <param name="sort">the sort criteria
            </param>
            <param name="numHits">the maximum number of hits to collect
            </param>
        </member>
        <member name="T:Lucene.Net.Search.Spans.SpanFirstQuery">
            <summary>Matches spans near the beginning of a field. </summary>
        </member>
        <member name="M:Lucene.Net.Search.Spans.SpanFirstQuery.#ctor(Lucene.Net.Search.Spans.SpanQuery,System.Int32)">
            <summary>Construct a SpanFirstQuery matching spans in <code>match</code> whose end
            position is less than or equal to <code>end</code>. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.Spans.SpanFirstQuery.GetMatch">
            <summary>Return the SpanQuery whose matches are filtered. </summary>
        </member>
        <member name="M:Lucene.Net.Search.Spans.SpanFirstQuery.GetEnd">
            <summary>Return the maximum end position permitted in a match. </summary>
        </member>
        <member name="M:Lucene.Net.Search.Spans.SpanFirstQuery.GetTerms">
            <summary>Returns a collection of all terms matched by this query.</summary>
            <deprecated> use extractTerms instead
            </deprecated>
            <seealso cref="!:ExtractTerms(Set)">
            </seealso>
        </member>
        <member name="T:Lucene.Net.Search.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="M:Lucene.Net.Search.PhraseScorer.Doc">
            <deprecated> use {@link #DocID()} instead. 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.PhraseScorer.Next">
            <deprecated> use {@link #NextDoc()} instead. 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.PhraseScorer.SkipTo(System.Int32)">
            <deprecated> use {@link #Advance(int)} instead. 
            </deprecated>
        </member>
        <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="T:Lucene.Net.Search.Payloads.MaxPayloadFunction">
            <summary> Returns the maximum payload score seen, else 1 if there are no payloads on the doc.
            <p/>
            Is thread safe and completely reusable.
            
            
            </summary>
        </member>
        <member name="T:Lucene.Net.Search.Payloads.PayloadFunction">
            <summary> An abstract class that defines a way for Payload*Query instances
            to transform the cumulative effects of payload scores for a document.
            
            </summary>
            <seealso cref="T:Lucene.Net.Search.Payloads.PayloadTermQuery"> for more information
            
            <p/>
            This class and its derivations are experimental and subject to change
            
            
            </seealso>
        </member>
        <member name="M:Lucene.Net.Search.Payloads.PayloadFunction.CurrentScore(System.Int32,System.String,System.Int32,System.Int32,System.Int32,System.Single,System.Single)">
            <summary> Calculate the score up to this point for this doc and field</summary>
            <param name="docId">The current doc
            </param>
            <param name="field">The field
            </param>
            <param name="start">The start position of the matching Span
            </param>
            <param name="end">The end position of the matching Span
            </param>
            <param name="numPayloadsSeen">The number of payloads seen so far
            </param>
            <param name="currentScore">The current score so far
            </param>
            <param name="currentPayloadScore">The score for the current payload
            </param>
            <returns> The new current Score
            
            </returns>
            <seealso cref="T:Lucene.Net.Search.Spans.Spans">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Search.Payloads.PayloadFunction.DocScore(System.Int32,System.String,System.Int32,System.Single)">
            <summary> Calculate the final score for all the payloads seen so far for this doc/field</summary>
            <param name="docId">The current doc
            </param>
            <param name="field">The current field
            </param>
            <param name="numPayloadsSeen">The total number of payloads seen on this document
            </param>
            <param name="payloadScore">The raw score for those payloads
            </param>
            <returns> The final score for the payloads
            </returns>
        </member>
        <member name="T:Lucene.Net.Search.Function.ByteFieldSource">
            <summary> Expert: obtains single byte field values from the 
            {@link Lucene.Net.Search.FieldCache FieldCache}
            using <code>getBytes()</code> and makes those values 
            available as other numeric types, casting as needed.
            
            <p/><font color="#FF0000">
            WARNING: The status of the <b>Search.Function</b> package is experimental. 
            The APIs introduced here might change in the future and will not be 
            supported anymore in such a case.</font>
            
            </summary>
            <seealso cref="T:Lucene.Net.Search.Function.FieldCacheSource"> for requirements"
            on the field. 
            
            <p/><b>NOTE</b>: with the switch in 2.9 to segment-based
            searching, if {@link #getValues} is invoked with a
            composite (multi-segment) reader, this can easily cause
            double RAM usage for the values in the FieldCache.  It's
            best to switch your application to pass only atomic
            (single segment) readers to this API.  Alternatively, for
            a short-term fix, you could wrap your ValueSource using
            {@link MultiValueSource}, which costs more CPU per lookup
            but will not consume double the FieldCache RAM.<p/>
            </seealso>
        </member>
        <member name="M:Lucene.Net.Search.Function.ByteFieldSource.#ctor(System.String)">
            <summary> Create a cached byte field source with default string-to-byte parser. </summary>
        </member>
        <member name="M:Lucene.Net.Search.Function.ByteFieldSource.#ctor(System.String,Lucene.Net.Search.ByteParser)">
            <summary> Create a cached byte field source with a specific string-to-byte parser. </summary>
        </member>
        <member name="T:Lucene.Net.Search.CreationPlaceholder">
            <summary> Expert: Maintains caches of term values.
            
            <p/>Created: May 19, 2004 11:13:14 AM
            
            </summary>
            <since>   lucene 1.4
            </since>
            <version>  $Id: FieldCache.java 807841 2009-08-25 22:27:31Z markrmiller $
            </version>
            <seealso cref="T:Lucene.Net.Util.FieldCacheSanityChecker">
            </seealso>
        </member>
        <member name="T:Lucene.Net.Search.StringIndex">
            <summary>Expert: Stores term text values and document ordering data. </summary>
        </member>
        <member name="F:Lucene.Net.Search.StringIndex.lookup">
            <summary>All the term values, in natural order. </summary>
        </member>
        <member name="F:Lucene.Net.Search.StringIndex.order">
            <summary>For each document, an index into the lookup array. </summary>
        </member>
        <member name="M:Lucene.Net.Search.StringIndex.#ctor(System.Int32[],System.String[])">
            <summary>Creates one of these objects </summary>
        </member>
        <member name="T:Lucene.Net.Search.CacheEntry">
            <summary> EXPERT: A unique Identifier/Description for each item in the FieldCache. 
            Can be useful for logging/debugging.
            <p/>
            <b>EXPERIMENTAL API:</b> This API is considered extremely advanced 
            and experimental.  It may be removed or altered w/o warning in future 
            releases 
            of Lucene.
            <p/>
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.CacheEntry.EstimateSize">
            <seealso cref="M:Lucene.Net.Search.CacheEntry.EstimateSize(Lucene.Net.Util.RamUsageEstimator)">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Search.CacheEntry.EstimateSize(Lucene.Net.Util.RamUsageEstimator)">
            <summary> Computes (and stores) the estimated size of the cache Value </summary>
            <seealso cref="!:getEstimatedSize">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Search.CacheEntry.GetEstimatedSize">
            <summary> The most recently estimated size of the value, null unless 
            estimateSize has been called.
            </summary>
        </member>
        <member name="F:Lucene.Net.Search.FieldCache_Fields.STRING_INDEX">
            <summary>Indicator for StringIndex values in the cache. </summary>
        </member>
        <member name="F:Lucene.Net.Search.FieldCache_Fields.DEFAULT">
            <summary>Expert: The cache used internally by sorting and range query classes. </summary>
        </member>
        <member name="F:Lucene.Net.Search.FieldCache_Fields.DEFAULT_BYTE_PARSER">
            <summary>The default parser for byte values, which are encoded by {@link Byte#toString(byte)} </summary>
        </member>
        <member name="F:Lucene.Net.Search.FieldCache_Fields.DEFAULT_SHORT_PARSER">
            <summary>The default parser for short values, which are encoded by {@link Short#toString(short)} </summary>
        </member>
        <member name="F:Lucene.Net.Search.FieldCache_Fields.DEFAULT_INT_PARSER">
            <summary>The default parser for int values, which are encoded by {@link Integer#toString(int)} </summary>
        </member>
        <member name="F:Lucene.Net.Search.FieldCache_Fields.DEFAULT_FLOAT_PARSER">
            <summary>The default parser for float values, which are encoded by {@link Float#toString(float)} </summary>
        </member>
        <member name="F:Lucene.Net.Search.FieldCache_Fields.DEFAULT_LONG_PARSER">
            <summary>The default parser for long values, which are encoded by {@link Long#toString(long)} </summary>
        </member>
        <member name="F:Lucene.Net.Search.FieldCache_Fields.DEFAULT_DOUBLE_PARSER">
            <summary>The default parser for double values, which are encoded by {@link Double#toString(double)} </summary>
        </member>
        <member name="F:Lucene.Net.Search.FieldCache_Fields.NUMERIC_UTILS_INT_PARSER">
            <summary> A parser instance for int values encoded by {@link NumericUtils#IntToPrefixCoded(int)}, e.g. when indexed
            via {@link NumericField}/{@link NumericTokenStream}.
            </summary>
        </member>
        <member name="F:Lucene.Net.Search.FieldCache_Fields.NUMERIC_UTILS_FLOAT_PARSER">
            <summary> A parser instance for float values encoded with {@link NumericUtils}, e.g. when indexed
            via {@link NumericField}/{@link NumericTokenStream}.
            </summary>
        </member>
        <member name="F:Lucene.Net.Search.FieldCache_Fields.NUMERIC_UTILS_LONG_PARSER">
            <summary> A parser instance for long values encoded by {@link NumericUtils#LongToPrefixCoded(long)}, e.g. when indexed
            via {@link NumericField}/{@link NumericTokenStream}.
            </summary>
        </member>
        <member name="F:Lucene.Net.Search.FieldCache_Fields.NUMERIC_UTILS_DOUBLE_PARSER">
            <summary> A parser instance for double values encoded with {@link NumericUtils}, e.g. when indexed
            via {@link NumericField}/{@link NumericTokenStream}.
            </summary>
        </member>
        <member name="T:Lucene.Net.Search.ByteParser">
            <summary>Interface to parse bytes from document fields.</summary>
            <seealso cref="!:FieldCache.GetBytes(IndexReader, String, FieldCache.ByteParser)">
            </seealso>
        </member>
        <member name="T:Lucene.Net.Search.Parser">
            <summary> Marker interface as super-interface to all parsers. It
            is used to specify a custom parser to {@link
            SortField#SortField(String, FieldCache.Parser)}.
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.ByteParser.ParseByte(System.String)">
            <summary>Return a single Byte representation of this field's value. </summary>
        </member>
        <member name="T:Lucene.Net.Search.ShortParser">
            <summary>Interface to parse shorts from document fields.</summary>
            <seealso cref="!:FieldCache.GetShorts(IndexReader, String, FieldCache.ShortParser)">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Search.ShortParser.ParseShort(System.String)">
            <summary>Return a short representation of this field's value. </summary>
        </member>
        <member name="T:Lucene.Net.Search.IntParser">
            <summary>Interface to parse ints from document fields.</summary>
            <seealso cref="!:FieldCache.GetInts(IndexReader, String, FieldCache.IntParser)">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Search.IntParser.ParseInt(System.String)">
            <summary>Return an integer representation of this field's value. </summary>
        </member>
        <member name="T:Lucene.Net.Search.FloatParser">
            <summary>Interface to parse floats from document fields.</summary>
            <seealso cref="!:FieldCache.GetFloats(IndexReader, String, FieldCache.FloatParser)">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Search.FloatParser.ParseFloat(System.String)">
            <summary>Return an float representation of this field's value. </summary>
        </member>
        <member name="T:Lucene.Net.Search.LongParser">
            <summary>Interface to parse long from document fields.</summary>
            <seealso cref="!:FieldCache.GetLongs(IndexReader, String, FieldCache.LongParser)">
            </seealso>
            <deprecated> Use {@link FieldCache.LongParser}, this will be removed in Lucene 3.0 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.LongParser.ParseLong(System.String)">
            <summary>Return an long representation of this field's value. </summary>
        </member>
        <member name="T:Lucene.Net.Search.DoubleParser">
            <summary>Interface to parse doubles from document fields.</summary>
            <seealso cref="!:FieldCache.GetDoubles(IndexReader, String, FieldCache.DoubleParser)">
            </seealso>
            <deprecated> Use {@link FieldCache.DoubleParser}, this will be removed in Lucene 3.0 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.DoubleParser.ParseDouble(System.String)">
            <summary>Return an long representation of this field's value. </summary>
        </member>
        <member name="M:Lucene.Net.Search.FieldCache.GetBytes(Lucene.Net.Index.IndexReader,System.String)">
            <summary>Checks the internal cache for an appropriate entry, and if none is
            found, reads the terms in <code>field</code> as a single byte and returns an array
            of size <code>reader.maxDoc()</code> of the value each document
            has in the given field.
            </summary>
            <param name="reader"> Used to get field values.
            </param>
            <param name="field">  Which field contains the single byte values.
            </param>
            <returns> The values in the given field for each document.
            </returns>
            <throws>  IOException  If any error occurs. </throws>
        </member>
        <member name="M:Lucene.Net.Search.FieldCache.GetBytes(Lucene.Net.Index.IndexReader,System.String,Lucene.Net.Search.ByteParser)">
            <summary>Checks the internal cache for an appropriate entry, and if none is found,
            reads the terms in <code>field</code> as bytes and returns an array of
            size <code>reader.maxDoc()</code> of the value each document has in the
            given field.
            </summary>
            <param name="reader"> Used to get field values.
            </param>
            <param name="field">  Which field contains the bytes.
            </param>
            <param name="parser"> Computes byte for string values.
            </param>
            <returns> The values in the given field for each document.
            </returns>
            <throws>  IOException  If any error occurs. </throws>
        </member>
        <member name="M:Lucene.Net.Search.FieldCache.GetShorts(Lucene.Net.Index.IndexReader,System.String)">
            <summary>Checks the internal cache for an appropriate entry, and if none is
            found, reads the terms in <code>field</code> as shorts and returns an array
            of size <code>reader.maxDoc()</code> of the value each document
            has in the given field.
            </summary>
            <param name="reader"> Used to get field values.
            </param>
            <param name="field">  Which field contains the shorts.
            </param>
            <returns> The values in the given field for each document.
            </returns>
            <throws>  IOException  If any error occurs. </throws>
        </member>
        <member name="M:Lucene.Net.Search.FieldCache.GetShorts(Lucene.Net.Index.IndexReader,System.String,Lucene.Net.Search.ShortParser)">
            <summary>Checks the internal cache for an appropriate entry, and if none is found,
            reads the terms in <code>field</code> as shorts and returns an array of
            size <code>reader.maxDoc()</code> of the value each document has in the
            given field.
            </summary>
            <param name="reader"> Used to get field values.
            </param>
            <param name="field">  Which field contains the shorts.
            </param>
            <param name="parser"> Computes short for string values.
            </param>
            <returns> The values in the given field for each document.
            </returns>
            <throws>  IOException  If any error occurs. </throws>
        </member>
        <member name="M:Lucene.Net.Search.FieldCache.GetInts(Lucene.Net.Index.IndexReader,System.String)">
            <summary>Checks the internal cache for an appropriate entry, and if none is
            found, reads the terms in <code>field</code> as integers and returns an array
            of size <code>reader.maxDoc()</code> of the value each document
            has in the given field.
            </summary>
            <param name="reader"> Used to get field values.
            </param>
            <param name="field">  Which field contains the integers.
            </param>
            <returns> The values in the given field for each document.
            </returns>
            <throws>  IOException  If any error occurs. </throws>
        </member>
        <member name="M:Lucene.Net.Search.FieldCache.GetInts(Lucene.Net.Index.IndexReader,System.String,Lucene.Net.Search.IntParser)">
            <summary>Checks the internal cache for an appropriate entry, and if none is found,
            reads the terms in <code>field</code> as integers and returns an array of
            size <code>reader.maxDoc()</code> of the value each document has in the
            given field.
            </summary>
            <param name="reader"> Used to get field values.
            </param>
            <param name="field">  Which field contains the integers.
            </param>
            <param name="parser"> Computes integer for string values.
            </param>
            <returns> The values in the given field for each document.
            </returns>
            <throws>  IOException  If any error occurs. </throws>
        </member>
        <member name="M:Lucene.Net.Search.FieldCache.GetFloats(Lucene.Net.Index.IndexReader,System.String)">
            <summary>Checks the internal cache for an appropriate entry, and if
            none is found, reads the terms in <code>field</code> as floats and returns an array
            of size <code>reader.maxDoc()</code> of the value each document
            has in the given field.
            </summary>
            <param name="reader"> Used to get field values.
            </param>
            <param name="field">  Which field contains the floats.
            </param>
            <returns> The values in the given field for each document.
            </returns>
            <throws>  IOException  If any error occurs. </throws>
        </member>
        <member name="M:Lucene.Net.Search.FieldCache.GetFloats(Lucene.Net.Index.IndexReader,System.String,Lucene.Net.Search.FloatParser)">
            <summary>Checks the internal cache for an appropriate entry, and if
            none is found, reads the terms in <code>field</code> as floats and returns an array
            of size <code>reader.maxDoc()</code> of the value each document
            has in the given field.
            </summary>
            <param name="reader"> Used to get field values.
            </param>
            <param name="field">  Which field contains the floats.
            </param>
            <param name="parser"> Computes float for string values.
            </param>
            <returns> The values in the given field for each document.
            </returns>
            <throws>  IOException  If any error occurs. </throws>
        </member>
        <member name="M:Lucene.Net.Search.FieldCache.GetLongs(Lucene.Net.Index.IndexReader,System.String)">
            <summary> Checks the internal cache for an appropriate entry, and if none is
            found, reads the terms in <code>field</code> as longs and returns an array
            of size <code>reader.maxDoc()</code> of the value each document
            has in the given field.
            
            </summary>
            <param name="reader">Used to get field values.
            </param>
            <param name="field"> Which field contains the longs.
            </param>
            <returns> The values in the given field for each document.
            </returns>
            <throws>  java.io.IOException If any error occurs. </throws>
        </member>
        <member name="M:Lucene.Net.Search.FieldCache.GetLongs(Lucene.Net.Index.IndexReader,System.String,Lucene.Net.Search.LongParser)">
            <summary> Checks the internal cache for an appropriate entry, and if none is found,
            reads the terms in <code>field</code> as longs and returns an array of
            size <code>reader.maxDoc()</code> of the value each document has in the
            given field.
            
            </summary>
            <param name="reader">Used to get field values.
            </param>
            <param name="field"> Which field contains the longs.
            </param>
            <param name="parser">Computes integer for string values.
            </param>
            <returns> The values in the given field for each document.
            </returns>
            <throws>  IOException If any error occurs. </throws>
        </member>
        <member name="M:Lucene.Net.Search.FieldCache.GetDoubles(Lucene.Net.Index.IndexReader,System.String)">
            <summary> Checks the internal cache for an appropriate entry, and if none is
            found, reads the terms in <code>field</code> as integers and returns an array
            of size <code>reader.maxDoc()</code> of the value each document
            has in the given field.
            
            </summary>
            <param name="reader">Used to get field values.
            </param>
            <param name="field"> Which field contains the doubles.
            </param>
            <returns> The values in the given field for each document.
            </returns>
            <throws>  IOException If any error occurs. </throws>
        </member>
        <member name="M:Lucene.Net.Search.FieldCache.GetDoubles(Lucene.Net.Index.IndexReader,System.String,Lucene.Net.Search.DoubleParser)">
            <summary> Checks the internal cache for an appropriate entry, and if none is found,
            reads the terms in <code>field</code> as doubles and returns an array of
            size <code>reader.maxDoc()</code> of the value each document has in the
            given field.
            
            </summary>
            <param name="reader">Used to get field values.
            </param>
            <param name="field"> Which field contains the doubles.
            </param>
            <param name="parser">Computes integer for string values.
            </param>
            <returns> The values in the given field for each document.
            </returns>
            <throws>  IOException If any error occurs. </throws>
        </member>
        <member name="M:Lucene.Net.Search.FieldCache.GetStrings(Lucene.Net.Index.IndexReader,System.String)">
            <summary>Checks the internal cache for an appropriate entry, and if none
            is found, reads the term values in <code>field</code> and returns an array
            of size <code>reader.maxDoc()</code> containing the value each document
            has in the given field.
            </summary>
            <param name="reader"> Used to get field values.
            </param>
            <param name="field">  Which field contains the strings.
            </param>
            <returns> The values in the given field for each document.
            </returns>
            <throws>  IOException  If any error occurs. </throws>
        </member>
        <member name="M:Lucene.Net.Search.FieldCache.GetStringIndex(Lucene.Net.Index.IndexReader,System.String)">
            <summary>Checks the internal cache for an appropriate entry, and if none
            is found reads the term values in <code>field</code> and returns
            an array of them in natural order, along with an array telling
            which element in the term array each document uses.
            </summary>
            <param name="reader"> Used to get field values.
            </param>
            <param name="field">  Which field contains the strings.
            </param>
            <returns> Array of terms and index into the array for each document.
            </returns>
            <throws>  IOException  If any error occurs. </throws>
        </member>
        <member name="M:Lucene.Net.Search.FieldCache.GetAuto(Lucene.Net.Index.IndexReader,System.String)">
            <summary>Checks the internal cache for an appropriate entry, and if
            none is found reads <code>field</code> to see if it contains integers, longs, floats
            or strings, and then calls one of the other methods in this class to get the
            values.  For string values, a StringIndex is returned.  After
            calling this method, there is an entry in the cache for both
            type <code>AUTO</code> and the actual found type.
            </summary>
            <param name="reader"> Used to get field values.
            </param>
            <param name="field">  Which field contains the values.
            </param>
            <returns> int[], long[], float[] or StringIndex.
            </returns>
            <throws>  IOException  If any error occurs. </throws>
            <deprecated> Please specify the exact type, instead.
            Especially, guessing does <b>not</b> work with the new
            {@link NumericField} type.
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.FieldCache.GetCustom(Lucene.Net.Index.IndexReader,System.String,Lucene.Net.Search.SortComparator)">
            <summary>Checks the internal cache for an appropriate entry, and if none
            is found reads the terms out of <code>field</code> and calls the given SortComparator
            to get the sort values.  A hit in the cache will happen if <code>reader</code>,
            <code>field</code>, and <code>comparator</code> are the same (using <code>equals()</code>)
            as a previous call to this method.
            </summary>
            <param name="reader"> Used to get field values.
            </param>
            <param name="field">  Which field contains the values.
            </param>
            <param name="comparator">Used to convert terms into something to sort by.
            </param>
            <returns> Array of sort objects, one for each document.
            </returns>
            <throws>  IOException  If any error occurs. </throws>
            <deprecated> Please implement {@link
            FieldComparatorSource} directly, instead.
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.FieldCache.GetCacheEntries">
            <summary> EXPERT: Generates an array of CacheEntry objects representing all items 
            currently in the FieldCache.
            <p/>
            NOTE: These CacheEntry objects maintain a strong refrence to the 
            Cached Values.  Maintaining refrences to a CacheEntry the IndexReader 
            associated with it has garbage collected will prevent the Value itself
            from being garbage collected when the Cache drops the WeakRefrence.
            <p/>
            <p/>
            <b>EXPERIMENTAL API:</b> This API is considered extremely advanced 
            and experimental.  It may be removed or altered w/o warning in future 
            releases 
            of Lucene.
            <p/>
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.FieldCache.PurgeAllCaches">
            <summary> <p/>
            EXPERT: Instructs the FieldCache to forcibly expunge all entries 
            from the underlying caches.  This is intended only to be used for 
            test methods as a way to ensure a known base state of the Cache 
            (with out needing to rely on GC to free WeakReferences).  
            It should not be relied on for "Cache maintenance" in general 
            application code.
            <p/>
            <p/>
            <b>EXPERIMENTAL API:</b> This API is considered extremely advanced 
            and experimental.  It may be removed or altered w/o warning in future 
            releases 
            of Lucene.
            <p/>
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.FieldCache.Purge(Lucene.Net.Index.IndexReader)">
            <summary>
            Expert: drops all cache entries associated with this
            reader.  NOTE: this reader must precisely match the
            reader that the cache entry is keyed on. If you pass a
            top-level reader, it usually will have no effect as
            Lucene now caches at the segment reader level.
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.FieldCache.SetInfoStream(System.IO.StreamWriter)">
            <summary> If non-null, FieldCacheImpl will warn whenever
            entries are created that are not sane according to
            {@link Lucene.Net.Util.FieldCacheSanityChecker}.
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.FieldCache.GetInfoStream">
            <summary>counterpart of {@link #SetInfoStream(PrintStream)} </summary>
        </member>
        <member name="T:Lucene.Net.Search.ComplexExplanation">
            <summary>Expert: Describes the score computation for document and query, and
            can distinguish a match independent of a positive value. 
            </summary>
        </member>
        <member name="T:Lucene.Net.Search.Explanation">
            <summary>Expert: Describes the score computation for document and query. </summary>
        </member>
        <member name="M:Lucene.Net.Search.Explanation.IsMatch">
            <summary> Indicates whether or not this Explanation models a good match.
            
            <p/>
            By default, an Explanation represents a "match" if the value is positive.
            <p/>
            </summary>
            <seealso cref="!:getValue">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Search.Explanation.GetValue">
            <summary>The value assigned to this explanation node. </summary>
        </member>
        <member name="M:Lucene.Net.Search.Explanation.SetValue(System.Single)">
            <summary>Sets the value assigned to this explanation node. </summary>
        </member>
        <member name="M:Lucene.Net.Search.Explanation.GetDescription">
            <summary>A description of this explanation node. </summary>
        </member>
        <member name="M:Lucene.Net.Search.Explanation.SetDescription(System.String)">
            <summary>Sets the description of this explanation node. </summary>
        </member>
        <member name="M:Lucene.Net.Search.Explanation.GetSummary">
            <summary> A short one line summary which should contain all high level
            information about this Explanation, without the "Details"
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.Explanation.GetDetails">
            <summary>The sub-nodes of this explanation node. </summary>
        </member>
        <member name="M:Lucene.Net.Search.Explanation.AddDetail(Lucene.Net.Search.Explanation)">
            <summary>Adds a sub-node to this explanation node. </summary>
        </member>
        <member name="M:Lucene.Net.Search.Explanation.ToString">
            <summary>Render an explanation as text. </summary>
        </member>
        <member name="M:Lucene.Net.Search.Explanation.ToHtml">
            <summary>Render an explanation as HTML. </summary>
        </member>
        <member name="T:Lucene.Net.Search.Explanation.IDFExplanation">
            <summary> Small Util class used to pass both an idf factor as well as an
            explanation for that factor.
            
            This class will likely be held on a {@link Weight}, so be aware 
            before storing any large or un-serializable fields.
            
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.Explanation.IDFExplanation.GetIdf">
            <returns> the idf factor
            </returns>
        </member>
        <member name="M:Lucene.Net.Search.Explanation.IDFExplanation.Explain">
            <summary> This should be calculated lazily if possible.
            
            </summary>
            <returns> the explanation for the idf factor.
            </returns>
        </member>
        <member name="M:Lucene.Net.Search.ComplexExplanation.GetMatch">
            <summary> The match status of this explanation node.</summary>
            <returns> May be null if match status is unknown
            </returns>
        </member>
        <member name="M:Lucene.Net.Search.ComplexExplanation.SetMatch(System.Nullable{System.Boolean})">
            <summary> Sets the match status assigned to this explanation node.</summary>
            <param name="match">May be null if match status is unknown
            </param>
        </member>
        <member name="M:Lucene.Net.Search.ComplexExplanation.IsMatch">
            <summary> Indicates whether or not this Explanation models a good match.
            
            <p/>
            If the match status is explicitly set (i.e.: not null) this method
            uses it; otherwise it defers to the superclass.
            <p/>
            </summary>
            <seealso cref="!:getMatch">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Index.SegmentTermDocs.Read(System.Int32[],System.Int32[])">
            <summary>Optimized implementation. </summary>
        </member>
        <member name="M:Lucene.Net.Index.SegmentTermDocs.SkipProx(System.Int64,System.Int32)">
            <summary>Overridden by SegmentTermPositions to skip in prox stream. </summary>
        </member>
        <member name="M:Lucene.Net.Index.SegmentTermDocs.SkipTo(System.Int32)">
            <summary>Optimized implementation. </summary>
        </member>
        <member name="M:Lucene.Net.Index.SegmentTermPositions.SkipProx(System.Int64,System.Int32)">
            <summary>Called by super.skipTo(). </summary>
        </member>
        <member name="T:Lucene.Net.Index.RawPostingList">
            <summary>This is the base class for an in-memory posting list,
            keyed by a Token.  {@link TermsHash} maintains a hash
            table holding one instance of this per unique Token.
            Consumers of TermsHash ({@link TermsHashConsumer}) must
            subclass this class with its own concrete class.
            FreqProxTermsWriter.PostingList is a private inner class used 
            for the freq/prox postings, and 
            TermVectorsTermsWriter.PostingList is a private inner class
            used to hold TermVectors postings. 
            </summary>
        </member>
        <member name="T:Lucene.Net.Index.IndexModifier">
            <summary> <p/>[Note that as of <b>2.1</b>, all but one of the
            methods in this class are available via {@link
            IndexWriter}.  The one method that is not available is
            {@link #DeleteDocument(int)}.]<p/>
            
            A class to modify an index, i.e. to delete and add documents. This
            class hides {@link IndexReader} and {@link IndexWriter} so that you
            do not need to care about implementation details such as that adding
            documents is done via IndexWriter and deletion is done via IndexReader.
            
            <p/>Note that you cannot create more than one <code>IndexModifier</code> object
            on the same directory at the same time.
            
            <p/>Example usage:
            
            <!-- ======================================================== -->
            <!-- = Java Sourcecode to HTML automatically converted code = -->
            <!-- =   Java2Html Converter V4.1 2004 by Markus Gebhard  markus@jave.de   = -->
            <!-- =     Further information: http://www.java2html.de     = -->
            <div align="left" class="java">
            <table border="0" cellpadding="3" cellspacing="0" bgcolor="#ffffff">
            <tr>
            <!-- start source code -->
            <td nowrap="nowrap" valign="top" align="left">
            <code>
            <font color="#ffffff">&#160;&#160;&#160;&#160;</font><font color="#000000">Analyzer&#160;analyzer&#160;=&#160;</font><font color="#7f0055"><b>new&#160;</b></font><font color="#000000">StandardAnalyzer</font><font color="#000000">()</font><font color="#000000">;</font><br/>
            <font color="#ffffff">&#160;&#160;&#160;&#160;</font><font color="#3f7f5f">//&#160;create&#160;an&#160;index&#160;in&#160;/tmp/index,&#160;overwriting&#160;an&#160;existing&#160;one:</font><br/>
            <font color="#ffffff">&#160;&#160;&#160;&#160;</font><font color="#000000">IndexModifier&#160;indexModifier&#160;=&#160;</font><font color="#7f0055"><b>new&#160;</b></font><font color="#000000">IndexModifier</font><font color="#000000">(</font><font color="#2a00ff">&#34;/tmp/index&#34;</font><font color="#000000">,&#160;analyzer,&#160;</font><font color="#7f0055"><b>true</b></font><font color="#000000">)</font><font color="#000000">;</font><br/>
            <font color="#ffffff">&#160;&#160;&#160;&#160;</font><font color="#000000">Document&#160;doc&#160;=&#160;</font><font color="#7f0055"><b>new&#160;</b></font><font color="#000000">Document</font><font color="#000000">()</font><font color="#000000">;</font><br/>
            <font color="#ffffff">&#160;&#160;&#160;&#160;</font><font color="#000000">doc.add</font><font color="#000000">(</font><font color="#7f0055"><b>new&#160;</b></font><font color="#000000">Field</font><font color="#000000">(</font><font color="#2a00ff">&#34;id&#34;</font><font color="#000000">,&#160;</font><font color="#2a00ff">&#34;1&#34;</font><font color="#000000">,&#160;Field.Store.YES,&#160;Field.Index.NOT_ANALYZED</font><font color="#000000">))</font><font color="#000000">;</font><br/>
            <font color="#ffffff">&#160;&#160;&#160;&#160;</font><font color="#000000">doc.add</font><font color="#000000">(</font><font color="#7f0055"><b>new&#160;</b></font><font color="#000000">Field</font><font color="#000000">(</font><font color="#2a00ff">&#34;body&#34;</font><font color="#000000">,&#160;</font><font color="#2a00ff">&#34;a&#160;simple&#160;test&#34;</font><font color="#000000">,&#160;Field.Store.YES,&#160;Field.Index.ANALYZED</font><font color="#000000">))</font><font color="#000000">;</font><br/>
            <font color="#ffffff">&#160;&#160;&#160;&#160;</font><font color="#000000">indexModifier.addDocument</font><font color="#000000">(</font><font color="#000000">doc</font><font color="#000000">)</font><font color="#000000">;</font><br/>
            <font color="#ffffff">&#160;&#160;&#160;&#160;</font><font color="#7f0055"><b>int&#160;</b></font><font color="#000000">deleted&#160;=&#160;indexModifier.delete</font><font color="#000000">(</font><font color="#7f0055"><b>new&#160;</b></font><font color="#000000">Term</font><font color="#000000">(</font><font color="#2a00ff">&#34;id&#34;</font><font color="#000000">,&#160;</font><font color="#2a00ff">&#34;1&#34;</font><font color="#000000">))</font><font color="#000000">;</font><br/>
            <font color="#ffffff">&#160;&#160;&#160;&#160;</font><font color="#000000">System.out.println</font><font color="#000000">(</font><font color="#2a00ff">&#34;Deleted&#160;&#34;&#160;</font><font color="#000000">+&#160;deleted&#160;+&#160;</font><font color="#2a00ff">&#34;&#160;document&#34;</font><font color="#000000">)</font><font color="#000000">;</font><br/>
            <font color="#ffffff">&#160;&#160;&#160;&#160;</font><font color="#000000">indexModifier.flush</font><font color="#000000">()</font><font color="#000000">;</font><br/>
            <font color="#ffffff">&#160;&#160;&#160;&#160;</font><font color="#000000">System.out.println</font><font color="#000000">(</font><font color="#000000">indexModifier.docCount</font><font color="#000000">()&#160;</font><font color="#000000">+&#160;</font><font color="#2a00ff">&#34;&#160;docs&#160;in&#160;index&#34;</font><font color="#000000">)</font><font color="#000000">;</font><br/>
            <font color="#ffffff">&#160;&#160;&#160;&#160;</font><font color="#000000">indexModifier.close</font><font color="#000000">()</font><font color="#000000">;</font></code>
            </td>
            <!-- end source code -->
            </tr>
            </table>
            </div>
            <!-- =       END of automatically generated HTML code       = -->
            <!-- ======================================================== -->
            
            <p/>Not all methods of IndexReader and IndexWriter are offered by this
            class. If you need access to additional methods, either use those classes
            directly or implement your own class that extends <code>IndexModifier</code>.
            
            <p/>Although an instance of this class can be used from more than one
            thread, you will not get the best performance. You might want to use
            IndexReader and IndexWriter directly for that (but you will need to
            care about synchronization yourself then).
            
            <p/>While you can freely mix calls to add() and delete() using this class,
            you should batch you calls for best performance. For example, if you
            want to update 20 documents, you should first delete all those documents,
            then add all the new documents.
            
            </summary>
            <deprecated> Please use {@link IndexWriter} instead.
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Index.IndexModifier.#ctor(Lucene.Net.Store.Directory,Lucene.Net.Analysis.Analyzer,System.Boolean)">
            <summary> Open an index with write access.
            
            </summary>
            <param name="directory">the index directory
            </param>
            <param name="analyzer">the analyzer to use for adding new documents
            </param>
            <param name="create"><code>true</code> to create the index or overwrite the existing one;
            <code>false</code> to append to the existing index
            </param>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  LockObtainFailedException if another writer </throws>
            <summary>  has this index open (<code>write.lock</code> could not
            be obtained)
            </summary>
            <throws>  IOException if there is a low-level IO error </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexModifier.#ctor(System.String,Lucene.Net.Analysis.Analyzer,System.Boolean)">
            <summary> Open an index with write access.
            
            </summary>
            <param name="dirName">the index directory
            </param>
            <param name="analyzer">the analyzer to use for adding new documents
            </param>
            <param name="create"><code>true</code> to create the index or overwrite the existing one;
            <code>false</code> to append to the existing index
            </param>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  LockObtainFailedException if another writer </throws>
            <summary>  has this index open (<code>write.lock</code> could not
            be obtained)
            </summary>
            <throws>  IOException if there is a low-level IO error </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexModifier.#ctor(System.IO.FileInfo,Lucene.Net.Analysis.Analyzer,System.Boolean)">
            <summary> Open an index with write access.
            
            </summary>
            <param name="file">the index directory
            </param>
            <param name="analyzer">the analyzer to use for adding new documents
            </param>
            <param name="create"><code>true</code> to create the index or overwrite the existing one;
            <code>false</code> to append to the existing index
            </param>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  LockObtainFailedException if another writer </throws>
            <summary>  has this index open (<code>write.lock</code> could not
            be obtained)
            </summary>
            <throws>  IOException if there is a low-level IO error </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexModifier.Init(Lucene.Net.Store.Directory,Lucene.Net.Analysis.Analyzer,System.Boolean)">
            <summary> Initialize an IndexWriter.</summary>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  LockObtainFailedException if another writer </throws>
            <summary>  has this index open (<code>write.lock</code> could not
            be obtained)
            </summary>
            <throws>  IOException if there is a low-level IO error </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexModifier.AssureOpen">
            <summary> Throw an IllegalStateException if the index is closed.</summary>
            <throws>  IllegalStateException </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexModifier.CreateIndexWriter">
            <summary> Close the IndexReader and open an IndexWriter.</summary>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  LockObtainFailedException if another writer </throws>
            <summary>  has this index open (<code>write.lock</code> could not
            be obtained)
            </summary>
            <throws>  IOException if there is a low-level IO error </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexModifier.CreateIndexReader">
            <summary> Close the IndexWriter and open an IndexReader.</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.IndexModifier.Flush">
            <summary> Make sure all changes are written to disk.</summary>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  LockObtainFailedException if another writer </throws>
            <summary>  has this index open (<code>write.lock</code> could not
            be obtained)
            </summary>
            <throws>  IOException if there is a low-level IO error </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexModifier.AddDocument(Lucene.Net.Documents.Document,Lucene.Net.Analysis.Analyzer)">
            <summary> Adds a document to this index, using the provided analyzer instead of the
            one specific in the constructor.  If the document contains more than
            {@link #SetMaxFieldLength(int)} terms for a given field, the remainder are
            discarded.
            </summary>
            <seealso cref="M:Lucene.Net.Index.IndexWriter.AddDocument(Lucene.Net.Documents.Document,Lucene.Net.Analysis.Analyzer)">
            </seealso>
            <throws>  IllegalStateException if the index is closed </throws>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  LockObtainFailedException if another writer </throws>
            <summary>  has this index open (<code>write.lock</code> could not
            be obtained)
            </summary>
            <throws>  IOException if there is a low-level IO error </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexModifier.AddDocument(Lucene.Net.Documents.Document)">
            <summary> Adds a document to this index.  If the document contains more than
            {@link #SetMaxFieldLength(int)} terms for a given field, the remainder are
            discarded.
            </summary>
            <seealso cref="M:Lucene.Net.Index.IndexWriter.AddDocument(Lucene.Net.Documents.Document)">
            </seealso>
            <throws>  IllegalStateException if the index is closed </throws>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  LockObtainFailedException if another writer </throws>
            <summary>  has this index open (<code>write.lock</code> could not
            be obtained)
            </summary>
            <throws>  IOException if there is a low-level IO error </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexModifier.DeleteDocuments(Lucene.Net.Index.Term)">
            <summary> Deletes all documents containing <code>term</code>.
            This is useful if one uses a document field to hold a unique ID string for
            the document.  Then to delete such a document, one merely constructs a
            term with the appropriate field and the unique ID string as its text and
            passes it to this method.  Returns the number of documents deleted.
            </summary>
            <returns> the number of documents deleted
            </returns>
            <seealso cref="M:Lucene.Net.Index.IndexReader.DeleteDocuments(Lucene.Net.Index.Term)">
            </seealso>
            <throws>  IllegalStateException if the index is closed </throws>
            <throws>  StaleReaderException if the index has changed </throws>
            <summary>  since this reader was opened
            </summary>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  LockObtainFailedException if another writer </throws>
            <summary>  has this index open (<code>write.lock</code> could not
            be obtained)
            </summary>
            <throws>  IOException if there is a low-level IO error </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexModifier.DeleteDocument(System.Int32)">
            <summary> Deletes the document numbered <code>docNum</code>.</summary>
            <seealso cref="M:Lucene.Net.Index.IndexReader.DeleteDocument(System.Int32)">
            </seealso>
            <throws>  StaleReaderException if the index has changed </throws>
            <summary>  since this reader was opened
            </summary>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  LockObtainFailedException if another writer </throws>
            <summary>  has this index open (<code>write.lock</code> could not
            be obtained)
            </summary>
            <throws>  IllegalStateException if the index is closed </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexModifier.DocCount">
            <summary> Returns the number of documents currently in this
            index.  If the writer is currently open, this returns
            {@link IndexWriter#DocCount()}, else {@link
            IndexReader#NumDocs()}.  But, note that {@link
            IndexWriter#DocCount()} does not take deletions into
            account, unlike {@link IndexReader#numDocs}.
            </summary>
            <throws>  IllegalStateException if the index is closed </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexModifier.Optimize">
            <summary> Merges all segments together into a single segment, optimizing an index
            for search.
            </summary>
            <seealso cref="M:Lucene.Net.Index.IndexWriter.Optimize">
            </seealso>
            <throws>  IllegalStateException if the index is closed </throws>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  LockObtainFailedException if another writer </throws>
            <summary>  has this index open (<code>write.lock</code> could not
            be obtained)
            </summary>
            <throws>  IOException if there is a low-level IO error </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexModifier.SetInfoStream(System.IO.StreamWriter)">
            <summary> If non-null, information about merges and a message when
            {@link #GetMaxFieldLength()} is reached will be printed to this.
            <p/>Example: <tt>index.setInfoStream(System.err);</tt>
            </summary>
            <seealso cref="!:IndexWriter.SetInfoStream(PrintStream)">
            </seealso>
            <throws>  IllegalStateException if the index is closed </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexModifier.GetInfoStream">
            <seealso cref="!:IndexModifier.SetInfoStream(PrintStream)">
            </seealso>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  LockObtainFailedException if another writer </throws>
            <summary>  has this index open (<code>write.lock</code> could not
            be obtained)
            </summary>
            <throws>  IOException if there is a low-level IO error </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexModifier.SetUseCompoundFile(System.Boolean)">
            <summary> Setting to turn on usage of a compound file. When on, multiple files
            for each segment are merged into a single file once the segment creation
            is finished. This is done regardless of what directory is in use.
            </summary>
            <seealso cref="!:IndexWriter.SetUseCompoundFile(boolean)">
            </seealso>
            <throws>  IllegalStateException if the index is closed </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexModifier.GetUseCompoundFile">
            <seealso cref="!:IndexModifier.SetUseCompoundFile(boolean)">
            </seealso>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  LockObtainFailedException if another writer </throws>
            <summary>  has this index open (<code>write.lock</code> could not
            be obtained)
            </summary>
            <throws>  IOException if there is a low-level IO error </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexModifier.SetMaxFieldLength(System.Int32)">
            <summary> The maximum number of terms that will be indexed for a single field in a
            document.  This limits the amount of memory required for indexing, so that
            collections with very large files will not crash the indexing process by
            running out of memory.<p/>
            Note that this effectively truncates large documents, excluding from the
            index terms that occur further in the document.  If you know your source
            documents are large, be sure to set this value high enough to accommodate
            the expected size.  If you set it to Integer.MAX_VALUE, then the only limit
            is your memory, but you should anticipate an OutOfMemoryError.<p/>
            By default, no more than 10,000 terms will be indexed for a field.
            </summary>
            <seealso cref="M:Lucene.Net.Index.IndexWriter.SetMaxFieldLength(System.Int32)">
            </seealso>
            <throws>  IllegalStateException if the index is closed </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexModifier.GetMaxFieldLength">
            <seealso cref="M:Lucene.Net.Index.IndexModifier.SetMaxFieldLength(System.Int32)">
            </seealso>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  LockObtainFailedException if another writer </throws>
            <summary>  has this index open (<code>write.lock</code> could not
            be obtained)
            </summary>
            <throws>  IOException if there is a low-level IO error </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexModifier.SetMaxBufferedDocs(System.Int32)">
            <summary> Determines the minimal number of documents required before the buffered
            in-memory documents are merging and a new Segment is created.
            Since Documents are merged in a {@link Lucene.Net.Store.RAMDirectory},
            large value gives faster indexing.  At the same time, mergeFactor limits
            the number of files open in a FSDirectory.
            
            <p/>The default value is 10.
            
            </summary>
            <seealso cref="M:Lucene.Net.Index.IndexWriter.SetMaxBufferedDocs(System.Int32)">
            </seealso>
            <throws>  IllegalStateException if the index is closed </throws>
            <throws>  IllegalArgumentException if maxBufferedDocs is smaller than 2 </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexModifier.GetMaxBufferedDocs">
            <seealso cref="M:Lucene.Net.Index.IndexModifier.SetMaxBufferedDocs(System.Int32)">
            </seealso>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  LockObtainFailedException if another writer </throws>
            <summary>  has this index open (<code>write.lock</code> could not
            be obtained)
            </summary>
            <throws>  IOException if there is a low-level IO error </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexModifier.SetMergeFactor(System.Int32)">
            <summary> Determines how often segment indices are merged by addDocument().  With
            smaller values, less RAM is used while indexing, and searches on
            unoptimized indices are faster, but indexing speed is slower.  With larger
            values, more RAM is used during indexing, and while searches on unoptimized
            indices are slower, indexing is faster.  Thus larger values (&gt; 10) are best
            for batch index creation, and smaller values (&lt; 10) for indices that are
            interactively maintained.
            <p/>This must never be less than 2.  The default value is 10.
            
            </summary>
            <seealso cref="M:Lucene.Net.Index.IndexWriter.SetMergeFactor(System.Int32)">
            </seealso>
            <throws>  IllegalStateException if the index is closed </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexModifier.GetMergeFactor">
            <seealso cref="M:Lucene.Net.Index.IndexModifier.SetMergeFactor(System.Int32)">
            </seealso>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  LockObtainFailedException if another writer </throws>
            <summary>  has this index open (<code>write.lock</code> could not
            be obtained)
            </summary>
            <throws>  IOException if there is a low-level IO error </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexModifier.Close">
            <summary> Close this index, writing all pending changes to disk.
            
            </summary>
            <throws>  IllegalStateException if the index has been closed before already </throws>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  IOException if there is a low-level IO error </throws>
        </member>
        <member name="T:Lucene.Net.Index.DocumentsWriterThreadState">
            <summary>Used by DocumentsWriter to maintain per-thread state.
            We keep a separate Posting hash and other state for each
            thread and then merge postings hashes from all threads
            when writing the segment. 
            </summary>
        </member>
        <member name="T:Lucene.Net.Analysis.TeeTokenFilter">
            <summary> Works in conjunction with the SinkTokenizer to provide the ability to set aside tokens
            that have already been analyzed.  This is useful in situations where multiple fields share
            many common analysis steps and then go their separate ways.
            <p/>
            It is also useful for doing things like entity extraction or proper noun analysis as
            part of the analysis workflow and saving off those tokens for use in another field.
            
            <pre>
            SinkTokenizer sink1 = new SinkTokenizer();
            SinkTokenizer sink2 = new SinkTokenizer();
            TokenStream source1 = new TeeTokenFilter(new TeeTokenFilter(new WhitespaceTokenizer(reader1), sink1), sink2);
            TokenStream source2 = new TeeTokenFilter(new TeeTokenFilter(new WhitespaceTokenizer(reader2), sink1), sink2);
            TokenStream final1 = new LowerCaseFilter(source1);
            TokenStream final2 = source2;
            TokenStream final3 = new EntityDetect(sink1);
            TokenStream final4 = new URLDetect(sink2);
            d.add(new Field("f1", final1));
            d.add(new Field("f2", final2));
            d.add(new Field("f3", final3));
            d.add(new Field("f4", final4));
            </pre>
            In this example, <code>sink1</code> and <code>sink2</code> will both get tokens from both
            <code>reader1</code> and <code>reader2</code> after whitespace tokenizer
            and now we can further wrap any of these in extra analysis, and more "sources" can be inserted if desired.
            It is important, that tees are consumed before sinks (in the above example, the field names must be
            less the sink's field names).
            Note, the EntityDetect and URLDetect TokenStreams are for the example and do not currently exist in Lucene
            <p/>
            
            See <a href="http://issues.apache.org/jira/browse/LUCENE-1058">LUCENE-1058</a>.
            <p/>
            WARNING: {@link TeeTokenFilter} and {@link SinkTokenizer} only work with the old TokenStream API.
            If you switch to the new API, you need to use {@link TeeSinkTokenFilter} instead, which offers 
            the same functionality.
            </summary>
            <seealso cref="T:Lucene.Net.Analysis.SinkTokenizer">
            </seealso>
            <deprecated> Use {@link TeeSinkTokenFilter} instead
            
            </deprecated>
        </member>
        <member name="T:Lucene.Net.Analysis.LowerCaseTokenizer">
            <summary> LowerCaseTokenizer performs the function of LetterTokenizer
            and LowerCaseFilter together.  It divides text at non-letters and converts
            them to lower case.  While it is functionally equivalent to the combination
            of LetterTokenizer and LowerCaseFilter, there is a performance advantage
            to doing the two tasks at once, hence this (redundant) implementation.
            <p/>
            Note: this does a decent job for most European languages, but does a terrible
            job for some Asian languages, where words are not separated by spaces.
            </summary>
        </member>
        <member name="T:Lucene.Net.Analysis.LetterTokenizer">
            <summary>A LetterTokenizer is a tokenizer that divides text at non-letters.  That's
            to say, it defines tokens as maximal strings of adjacent letters, as defined
            by java.lang.Character.isLetter() predicate.
            Note: this does a decent job for most European languages, but does a terrible
            job for some Asian languages, where words are not separated by spaces. 
            </summary>
        </member>
        <member name="T:Lucene.Net.Analysis.CharTokenizer">
            <summary>An abstract base class for simple, character-oriented tokenizers.</summary>
        </member>
        <member name="T:Lucene.Net.Analysis.Tokenizer">
            <summary> A Tokenizer is a TokenStream whose input is a Reader.
            <p/>
            This is an abstract class; subclasses must override {@link #IncrementToken()}
            <p/>
            NOTE: Subclasses overriding {@link #next(Token)} must call
            {@link AttributeSource#ClearAttributes()} before setting attributes.
            Subclasses overriding {@link #IncrementToken()} must call
            {@link Token#Clear()} before setting Token attributes.
            </summary>
        </member>
        <member name="F:Lucene.Net.Analysis.Tokenizer.input">
            <summary>The text source for this Tokenizer. </summary>
        </member>
        <member name="M:Lucene.Net.Analysis.Tokenizer.#ctor">
            <summary>Construct a tokenizer with null input. </summary>
        </member>
        <member name="M:Lucene.Net.Analysis.Tokenizer.#ctor(System.IO.TextReader)">
            <summary>Construct a token stream processing the given input. </summary>
        </member>
        <member name="M:Lucene.Net.Analysis.Tokenizer.#ctor(Lucene.Net.Util.AttributeSource.AttributeFactory)">
            <summary>Construct a tokenizer with null input using the given AttributeFactory. </summary>
        </member>
        <member name="M:Lucene.Net.Analysis.Tokenizer.#ctor(Lucene.Net.Util.AttributeSource.AttributeFactory,System.IO.TextReader)">
            <summary>Construct a token stream processing the given input using the given AttributeFactory. </summary>
        </member>
        <member name="M:Lucene.Net.Analysis.Tokenizer.#ctor(Lucene.Net.Util.AttributeSource)">
            <summary>Construct a token stream processing the given input using the given AttributeSource. </summary>
        </member>
        <member name="M:Lucene.Net.Analysis.Tokenizer.#ctor(Lucene.Net.Util.AttributeSource,System.IO.TextReader)">
            <summary>Construct a token stream processing the given input using the given AttributeSource. </summary>
        </member>
        <member name="M:Lucene.Net.Analysis.Tokenizer.Close">
            <summary>By default, closes the input Reader. </summary>
        </member>
        <member name="M:Lucene.Net.Analysis.Tokenizer.CorrectOffset(System.Int32)">
            <summary>Return the corrected offset. If {@link #input} is a {@link CharStream} subclass
            this method calls {@link CharStream#CorrectOffset}, else returns <code>currentOff</code>.
            </summary>
            <param name="currentOff">offset as seen in the output
            </param>
            <returns> corrected offset based on the input
            </returns>
            <seealso cref="M:Lucene.Net.Analysis.CharStream.CorrectOffset(System.Int32)">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Analysis.Tokenizer.Reset(System.IO.TextReader)">
            <summary>Expert: Reset the tokenizer to a new reader.  Typically, an
            analyzer (in its reusableTokenStream method) will use
            this to re-use a previously created tokenizer. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Analysis.CharTokenizer.IsTokenChar(System.Char)">
            <summary>Returns true iff a character should be included in a token.  This
            tokenizer generates as tokens adjacent sequences of characters which
            satisfy this predicate.  Characters for which this is false are used to
            define token boundaries and are not included in tokens. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Analysis.CharTokenizer.Normalize(System.Char)">
            <summary>Called on each token character to normalize it before it is added to the
            token.  The default implementation does nothing.  Subclasses may use this
            to, e.g., lowercase tokens. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Analysis.CharTokenizer.Next(Lucene.Net.Analysis.Token)">
            <deprecated> Will be removed in Lucene 3.0. This method is final, as it should
            not be overridden. Delegates to the backwards compatibility layer. 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Analysis.CharTokenizer.Next">
            <deprecated> Will be removed in Lucene 3.0. This method is final, as it should
            not be overridden. Delegates to the backwards compatibility layer. 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Analysis.LetterTokenizer.#ctor(System.IO.TextReader)">
            <summary>Construct a new LetterTokenizer. </summary>
        </member>
        <member name="M:Lucene.Net.Analysis.LetterTokenizer.#ctor(Lucene.Net.Util.AttributeSource,System.IO.TextReader)">
            <summary>Construct a new LetterTokenizer using a given {@link AttributeSource}. </summary>
        </member>
        <member name="M:Lucene.Net.Analysis.LetterTokenizer.#ctor(Lucene.Net.Util.AttributeSource.AttributeFactory,System.IO.TextReader)">
            <summary>Construct a new LetterTokenizer using a given {@link Lucene.Net.Util.AttributeSource.AttributeFactory}. </summary>
        </member>
        <member name="M:Lucene.Net.Analysis.LetterTokenizer.IsTokenChar(System.Char)">
            <summary>Collects only characters which satisfy
            {@link Character#isLetter(char)}.
            </summary>
        </member>
        <member name="M:Lucene.Net.Analysis.LowerCaseTokenizer.#ctor(System.IO.TextReader)">
            <summary>Construct a new LowerCaseTokenizer. </summary>
        </member>
        <member name="M:Lucene.Net.Analysis.LowerCaseTokenizer.#ctor(Lucene.Net.Util.AttributeSource,System.IO.TextReader)">
            <summary>Construct a new LowerCaseTokenizer using a given {@link AttributeSource}. </summary>
        </member>
        <member name="M:Lucene.Net.Analysis.LowerCaseTokenizer.#ctor(Lucene.Net.Util.AttributeSource.AttributeFactory,System.IO.TextReader)">
            <summary>Construct a new LowerCaseTokenizer using a given {@link Lucene.Net.Util.AttributeSource.AttributeFactory}. </summary>
        </member>
        <member name="M:Lucene.Net.Analysis.LowerCaseTokenizer.Normalize(System.Char)">
            <summary>Converts char to lower case
            {@link Character#toLowerCase(char)}.
            </summary>
        </member>
        <member name="T:Lucene.Net.Store.RAMInputStream">
            <summary> A memory-resident {@link IndexInput} implementation.
            
            </summary>
            <version>  $Id: RAMInputStream.java 632120 2008-02-28 21:13:59Z mikemccand $
            </version>
        </member>
        <member name="T:Lucene.Net.Search.SortComparator">
            <summary> Abstract base class for sorting hits returned by a Query.
            
            <p/>
            This class should only be used if the other SortField types (SCORE, DOC,
            STRING, INT, FLOAT) do not provide an adequate sorting. It maintains an
            internal cache of values which could be quite large. The cache is an array of
            Comparable, one for each document in the index. There is a distinct
            Comparable for each unique term in the field - if some documents have the
            same term in the field, the cache array will have entries which reference the
            same Comparable.
            
            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.
            
            <p/>
            Created: Apr 21, 2004 5:08:38 PM
            
            
            </summary>
            <version>  $Id: SortComparator.java 800119 2009-08-02 17:59:21Z markrmiller $
            </version>
            <since> 1.4
            </since>
            <deprecated> Please use {@link FieldComparatorSource} instead.
            </deprecated>
        </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: SortComparatorSource.java 747019 2009-02-23 13:59:50Z
            mikemccand $
            </version>
            <since> 1.4
            </since>
            <deprecated> Please use {@link FieldComparatorSource} instead.
            </deprecated>
        </member>
        <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.SortComparator.GetComparable(System.String)">
            <summary> Returns an object which, when sorted according to natural order,
            will order the Term values in the correct order.
            <p/>For example, if the Terms contained integer values, this method
            would return <code>new Integer(termtext)</code>.  Note that this
            might not always be the most efficient implementation - for this
            particular example, a better implementation might be to make a
            ScoreDocLookupComparator that uses an internal lookup table of int.
            </summary>
            <param name="termtext">The textual value of the term.
            </param>
            <returns> An object representing <code>termtext</code> that sorts according to the natural order of <code>termtext</code>.
            </returns>
            <seealso cref="!:Comparable">
            </seealso>
            <seealso cref="T:Lucene.Net.Search.ScoreDocComparator">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Search.ScoreDocComparator.Compare(Lucene.Net.Search.ScoreDoc,Lucene.Net.Search.ScoreDoc)">
            <summary> Compares two ScoreDoc objects and returns a result indicating their
            sort order.
            </summary>
            <param name="i">First ScoreDoc
            </param>
            <param name="j">Second ScoreDoc
            </param>
            <returns> a negative integer if <code>i</code> should come before <code>j</code><br/>
            a positive integer if <code>i</code> should come after <code>j</code><br/>
            <code>0</code> if they are equal
            </returns>
            <seealso cref="!:java.util.Comparator">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Search.ScoreDocComparator.SortValue(Lucene.Net.Search.ScoreDoc)">
            <summary> Returns the value used to sort the given document.  The
            object returned must implement the java.io.Serializable
            interface.  This is used by multisearchers to determine how
            to collate results from their searchers.
            </summary>
            <seealso cref="T:Lucene.Net.Search.FieldDoc">
            </seealso>
            <param name="i">Document
            </param>
            <returns> Serializable object
            </returns>
        </member>
        <member name="M:Lucene.Net.Search.ScoreDocComparator.SortType">
            <summary> Returns the type of sort.  Should return <code>SortField.SCORE</code>,
            <code>SortField.DOC</code>, <code>SortField.STRING</code>,
            <code>SortField.INTEGER</code>, <code>SortField.FLOAT</code> or
            <code>SortField.CUSTOM</code>.  It is not valid to return
            <code>SortField.AUTO</code>.
            This is used by multisearchers to determine how to collate results
            from their searchers.
            </summary>
            <returns> One of the constants in SortField.
            </returns>
            <seealso cref="T:Lucene.Net.Search.SortField">
            </seealso>
        </member>
        <member name="T:Lucene.Net.Search.ScoreCachingWrappingScorer">
            <summary> A {@link Scorer} which wraps another scorer and caches the score of the
            current document. Successive calls to {@link #Score()} will return the same
            result and will not invoke the wrapped Scorer's score() method, unless the
            current document has changed.<br/>
            This class might be useful due to the changes done to the {@link Collector}
            interface, in which the score is not computed for a document by default, only
            if the collector requests it. Some collectors may need to use the score in
            several places, however all they have in hand is a {@link Scorer} object, and
            might end up computing the score of a document more than once.
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.ScoreCachingWrappingScorer.#ctor(Lucene.Net.Search.Scorer)">
            <summary>Creates a new instance by wrapping the given scorer. </summary>
        </member>
        <member name="M:Lucene.Net.Search.ScoreCachingWrappingScorer.Doc">
            <deprecated> use {@link #DocID()} instead. 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.ScoreCachingWrappingScorer.Next">
            <deprecated> use {@link #NextDoc()} instead. 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.ScoreCachingWrappingScorer.SkipTo(System.Int32)">
            <deprecated> use {@link #Advance(int)} instead. 
            </deprecated>
        </member>
        <member name="T:Lucene.Net.Search.HitCollectorWrapper">
            <summary> Wrapper for ({@link HitCollector}) implementations, which simply re-bases the
            incoming docID before calling {@link HitCollector#collect}.
            
            </summary>
            <deprecated> Please migrate custom HitCollectors to the new {@link Collector}
            class. This class will be removed when {@link HitCollector} is
            removed.
            </deprecated>
        </member>
        <member name="T:Lucene.Net.Search.Function.IntFieldSource">
            <summary> Expert: obtains int field values from the 
            {@link Lucene.Net.Search.FieldCache FieldCache}
            using <code>getInts()</code> and makes those values 
            available as other numeric types, casting as needed.
            
            <p/><font color="#FF0000">
            WARNING: The status of the <b>Search.Function</b> package is experimental. 
            The APIs introduced here might change in the future and will not be 
            supported anymore in such a case.</font>
            
            </summary>
            <seealso cref="T:Lucene.Net.Search.Function.FieldCacheSource"> for requirements
            on the field.
            
            <p/><b>NOTE</b>: with the switch in 2.9 to segment-based
            searching, if {@link #getValues} is invoked with a
            composite (multi-segment) reader, this can easily cause
            double RAM usage for the values in the FieldCache.  It's
            best to switch your application to pass only atomic
            (single segment) readers to this API.  Alternatively, for
            a short-term fix, you could wrap your ValueSource using
            {@link MultiValueSource}, which costs more CPU per lookup
            but will not consume double the FieldCache RAM.<p/>
            </seealso>
        </member>
        <member name="M:Lucene.Net.Search.Function.IntFieldSource.#ctor(System.String)">
            <summary> Create a cached int field source with default string-to-int parser. </summary>
        </member>
        <member name="M:Lucene.Net.Search.Function.IntFieldSource.#ctor(System.String,Lucene.Net.Search.IntParser)">
            <summary> Create a cached int field source with a specific string-to-int parser. </summary>
        </member>
        <member name="T:Lucene.Net.Search.FieldSortedHitQueue">
            <summary> Expert: A hit queue for sorting by hits by terms in more than one field.
            Uses <code>FieldCache.DEFAULT</code> for maintaining internal term lookup tables.
            
            <p/>Created: Dec 8, 2003 12:56:03 PM
            
            </summary>
            <since>   lucene 1.4
            </since>
            <version>  $Id: FieldSortedHitQueue.java 803676 2009-08-12 19:31:38Z hossman $
            </version>
            <seealso cref="M:Lucene.Net.Search.Searcher.Search(Lucene.Net.Search.Query,Lucene.Net.Search.Filter,System.Int32,Lucene.Net.Search.Sort)">
            </seealso>
            <seealso cref="T:Lucene.Net.Search.FieldCache">
            </seealso>
            <deprecated> see {@link FieldValueHitQueue}
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.FieldSortedHitQueue.#ctor(Lucene.Net.Index.IndexReader,Lucene.Net.Search.SortField[],System.Int32)">
            <summary> Creates a hit queue sorted by the given list of fields.</summary>
            <param name="reader"> Index to use.
            </param>
            <param name="fields">Fieldable names, in priority order (highest priority first).  Cannot be <code>null</code> or empty.
            </param>
            <param name="size"> The number of hits to retain.  Must be greater than zero.
            </param>
            <throws>  IOException </throws>
        </member>
        <member name="F:Lucene.Net.Search.FieldSortedHitQueue.comparators">
            <summary>Stores a comparator corresponding to each field being sorted by </summary>
        </member>
        <member name="F:Lucene.Net.Search.FieldSortedHitQueue.fields">
            <summary>Stores the sort criteria being used. </summary>
        </member>
        <member name="F:Lucene.Net.Search.FieldSortedHitQueue.maxscore">
            <summary>Stores the maximum score value encountered, needed for normalizing. </summary>
        </member>
        <member name="M:Lucene.Net.Search.FieldSortedHitQueue.GetMaxScore">
            <summary>returns the maximum score encountered by elements inserted via insert()</summary>
        </member>
        <member name="M:Lucene.Net.Search.FieldSortedHitQueue.LessThan(System.Object,System.Object)">
            <summary> Returns whether <code>a</code> is less relevant than <code>b</code>.</summary>
            <param name="a">ScoreDoc
            </param>
            <param name="b">ScoreDoc
            </param>
            <returns> <code>true</code> if document <code>a</code> should be sorted after document <code>b</code>.
            </returns>
        </member>
        <member name="M:Lucene.Net.Search.FieldSortedHitQueue.FillFields(Lucene.Net.Search.FieldDoc)">
            <summary> Given a FieldDoc object, stores the values used
            to sort the given document.  These values are not the raw
            values out of the index, but the internal representation
            of them.  This is so the given search hit can be collated
            by a MultiSearcher with other search hits.
            </summary>
            <param name="doc"> The FieldDoc to store sort values into.
            </param>
            <returns>  The same FieldDoc passed in.
            </returns>
            <seealso cref="M:Lucene.Net.Search.Searchable.Search(Lucene.Net.Search.Weight,Lucene.Net.Search.Filter,System.Int32,Lucene.Net.Search.Sort)">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Search.FieldSortedHitQueue.GetFields">
            <summary>Returns the SortFields being used by this hit queue. </summary>
        </member>
        <member name="F:Lucene.Net.Search.FieldSortedHitQueue.Comparators">
            <summary>Internal cache of comparators. Similar to FieldCache, only
            caches comparators instead of term values. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.FieldSortedHitQueue.comparatorByte(Lucene.Net.Index.IndexReader,System.String,Lucene.Net.Search.ByteParser)">
            <summary> Returns a comparator for sorting hits according to a field containing bytes.</summary>
            <param name="reader"> Index to use.
            </param>
            <param name="fieldname"> Fieldable containing integer values.
            </param>
            <returns>  Comparator for sorting hits.
            </returns>
            <throws>  IOException If an error occurs reading the index. </throws>
        </member>
        <member name="M:Lucene.Net.Search.FieldSortedHitQueue.comparatorShort(Lucene.Net.Index.IndexReader,System.String,Lucene.Net.Search.ShortParser)">
            <summary> Returns a comparator for sorting hits according to a field containing shorts.</summary>
            <param name="reader"> Index to use.
            </param>
            <param name="fieldname"> Fieldable containing integer values.
            </param>
            <returns>  Comparator for sorting hits.
            </returns>
            <throws>  IOException If an error occurs reading the index. </throws>
        </member>
        <member name="M:Lucene.Net.Search.FieldSortedHitQueue.comparatorInt(Lucene.Net.Index.IndexReader,System.String,Lucene.Net.Search.IntParser)">
            <summary> Returns a comparator for sorting hits according to a field containing integers.</summary>
            <param name="reader"> Index to use.
            </param>
            <param name="fieldname"> Fieldable containing integer values.
            </param>
            <returns>  Comparator for sorting hits.
            </returns>
            <throws>  IOException If an error occurs reading the index. </throws>
        </member>
        <member name="M:Lucene.Net.Search.FieldSortedHitQueue.comparatorLong(Lucene.Net.Index.IndexReader,System.String,Lucene.Net.Search.LongParser)">
            <summary> Returns a comparator for sorting hits according to a field containing integers.</summary>
            <param name="reader"> Index to use.
            </param>
            <param name="fieldname"> Fieldable containing integer values.
            </param>
            <returns>  Comparator for sorting hits.
            </returns>
            <throws>  IOException If an error occurs reading the index. </throws>
        </member>
        <member name="M:Lucene.Net.Search.FieldSortedHitQueue.comparatorFloat(Lucene.Net.Index.IndexReader,System.String,Lucene.Net.Search.FloatParser)">
            <summary> Returns a comparator for sorting hits according to a field containing floats.</summary>
            <param name="reader"> Index to use.
            </param>
            <param name="fieldname"> Fieldable containing float values.
            </param>
            <returns>  Comparator for sorting hits.
            </returns>
            <throws>  IOException If an error occurs reading the index. </throws>
        </member>
        <member name="M:Lucene.Net.Search.FieldSortedHitQueue.comparatorDouble(Lucene.Net.Index.IndexReader,System.String,Lucene.Net.Search.DoubleParser)">
            <summary> Returns a comparator for sorting hits according to a field containing doubles.</summary>
            <param name="reader"> Index to use.
            </param>
            <param name="fieldname"> Fieldable containing float values.
            </param>
            <returns>  Comparator for sorting hits.
            </returns>
            <throws>  IOException If an error occurs reading the index. </throws>
        </member>
        <member name="M:Lucene.Net.Search.FieldSortedHitQueue.comparatorString(Lucene.Net.Index.IndexReader,System.String)">
            <summary> Returns a comparator for sorting hits according to a field containing strings.</summary>
            <param name="reader"> Index to use.
            </param>
            <param name="fieldname"> Fieldable containing string values.
            </param>
            <returns>  Comparator for sorting hits.
            </returns>
            <throws>  IOException If an error occurs reading the index. </throws>
        </member>
        <member name="M:Lucene.Net.Search.FieldSortedHitQueue.comparatorStringLocale(Lucene.Net.Index.IndexReader,System.String,System.Globalization.CultureInfo)">
            <summary> Returns a comparator for sorting hits according to a field containing strings.</summary>
            <param name="reader"> Index to use.
            </param>
            <param name="fieldname"> Fieldable containing string values.
            </param>
            <returns>  Comparator for sorting hits.
            </returns>
            <throws>  IOException If an error occurs reading the index. </throws>
        </member>
        <member name="M:Lucene.Net.Search.FieldSortedHitQueue.ComparatorAuto(Lucene.Net.Index.IndexReader,System.String)">
            <summary> Returns a comparator for sorting hits according to values in the given field.
            The terms in the field are looked at to determine whether they contain integers,
            floats or strings.  Once the type is determined, one of the other static methods
            in this class is called to get the comparator.
            </summary>
            <param name="reader"> Index to use.
            </param>
            <param name="fieldname"> Fieldable containing values.
            </param>
            <returns>  Comparator for sorting hits.
            </returns>
            <throws>  IOException If an error occurs reading the index. </throws>
        </member>
        <member name="T:Lucene.Net.Search.FieldCacheImpl.Cache">
            <summary>Expert: Internal cache. </summary>
        </member>
        <member name="T:Lucene.Net.Search.FieldCacheImpl">
            <summary> Expert: The default cache implementation, storing all values in memory.
            A WeakHashMap is used for storage.
            
            <p/>Created: May 19, 2004 4:40:36 PM
            
            </summary>
            <since>   lucene 1.4
            </since>
            <version>  $Id: FieldCacheImpl.java 807572 2009-08-25 11:44:45Z mikemccand $
            </version>
        </member>
        <member name="M:Lucene.Net.Search.ExtendedFieldCache_old.ExtendedFieldCache.GetLongs(Lucene.Net.Index.IndexReader,System.String,Lucene.Net.Search.LongParser)">
            <deprecated> Will be removed in 3.0, this is for binary compatibility only 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.ExtendedFieldCache_old.ExtendedFieldCache.GetDoubles(Lucene.Net.Index.IndexReader,System.String,Lucene.Net.Search.DoubleParser)">
            <deprecated> Will be removed in 3.0, this is for binary compatibility only 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.FieldCacheImpl.GetLongs(Lucene.Net.Index.IndexReader,System.String,Lucene.Net.Search.ExtendedFieldCache_old.LongParser)">
            <deprecated> Will be removed in 3.0, this is for binary compatibility only 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.FieldCacheImpl.GetDoubles(Lucene.Net.Index.IndexReader,System.String,Lucene.Net.Search.ExtendedFieldCache_old.DoubleParser)">
            <deprecated> Will be removed in 3.0, this is for binary compatibility only 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.FieldCacheImpl.GetAuto(Lucene.Net.Index.IndexReader,System.String)">
            <summary>The pattern used to detect float values in a field </summary>
            <summary> removed for java 1.3 compatibility
            protected static final Object pFloats = Pattern.compile ("[0-9+\\-\\.eEfFdD]+");
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.FieldCacheImpl.GetCustom(Lucene.Net.Index.IndexReader,System.String,Lucene.Net.Search.SortComparator)">
            <deprecated> 
            </deprecated>
        </member>
        <member name="F:Lucene.Net.Search.FieldCacheImpl.CacheEntryImpl.sortFieldType">
            <deprecated> Only needed because of Entry (ab)use by 
            FieldSortedHitQueue, remove when FieldSortedHitQueue 
            is removed
            </deprecated>
        </member>
        <member name="F:Lucene.Net.Search.FieldCacheImpl.CacheEntryImpl.locale">
            <deprecated> Only needed because of Entry (ab)use by 
            FieldSortedHitQueue, remove when FieldSortedHitQueue 
            is removed
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.FieldCacheImpl.CacheEntryImpl.ToString">
            <summary> Adds warning to super.toString if Local or sortFieldType were specified</summary>
            <deprecated> Only needed because of Entry (ab)use by 
            FieldSortedHitQueue, remove when FieldSortedHitQueue 
            is removed
            </deprecated>
        </member>
        <member name="T:Lucene.Net.Search.FieldCacheImpl.StopFillCacheException">
            <summary> Hack: When thrown from a Parser (NUMERIC_UTILS_* ones), this stops
            processing terms and returns the current FieldCache
            array.
            </summary>
        </member>
        <member name="T:Lucene.Net.Search.FieldCacheImpl.Cache">
            <summary>Expert: Internal cache. </summary>
        </member>
        <member name="M:Lucene.Net.Search.FieldCacheImpl.Cache.Purge(Lucene.Net.Index.IndexReader)">
            Remove this reader from the cache, if present. 
        </member>
        <member name="T:Lucene.Net.Search.FieldCacheImpl.Entry">
            <summary>Expert: Every composite-key in the internal cache is of this type. </summary>
        </member>
        <member name="F:Lucene.Net.Search.FieldCacheImpl.Entry.type">
            <deprecated> Only (ab)used by FieldSortedHitQueue, 
            remove when FieldSortedHitQueue is removed
            </deprecated>
        </member>
        <member name="F:Lucene.Net.Search.FieldCacheImpl.Entry.locale">
            <deprecated> Only (ab)used by FieldSortedHitQueue, 
            remove when FieldSortedHitQueue is removed
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.FieldCacheImpl.Entry.#ctor(System.String,System.Int32,System.Globalization.CultureInfo)">
            <deprecated> Only (ab)used by FieldSortedHitQueue, 
            remove when FieldSortedHitQueue is removed
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.FieldCacheImpl.Entry.#ctor(System.String,System.Object)">
            <summary>Creates one of these objects for a custom comparator/parser. </summary>
        </member>
        <member name="M:Lucene.Net.Search.FieldCacheImpl.Entry.#ctor(System.String,System.Int32,Lucene.Net.Search.Parser)">
            <deprecated> Only (ab)used by FieldSortedHitQueue, 
            remove when FieldSortedHitQueue is removed
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.FieldCacheImpl.Entry.Equals(System.Object)">
            <summary>Two of these are equal iff they reference the same field and type. </summary>
        </member>
        <member name="M:Lucene.Net.Search.FieldCacheImpl.Entry.GetHashCode">
            <summary>Composes a hashcode based on the field and type. </summary>
        </member>
        <member name="T:Lucene.Net.Search.FieldCacheImpl.AutoCache">
            <deprecated> Please specify the exact type, instead.
            Especially, guessing does <b>not</b> work with the new
            {@link NumericField} type.
            </deprecated>
        </member>
        <member name="T:Lucene.Net.Search.FieldCacheImpl.CustomCache">
            <deprecated> 
            </deprecated>
        </member>
        <member name="T:Lucene.Net.Search.FieldComparator">
            <summary> Expert: a FieldComparator compares hits so as to determine their
            sort order when collecting the top results with {@link
            TopFieldCollector}.  The concrete public FieldComparator
            classes here correspond to the SortField types.
            
            <p/>This API is designed to achieve high performance
            sorting, by exposing a tight interaction with {@link
            FieldValueHitQueue} as it visits hits.  Whenever a hit is
            competitive, it's enrolled into a virtual slot, which is
            an int ranging from 0 to numHits-1.  The {@link
            FieldComparator} is made aware of segment transitions
            during searching in case any internal state it's tracking
            needs to be recomputed during these transitions.<p/>
            
            <p/>A comparator must define these functions:<p/>
            
            <ul>
            
            <li> {@link #compare} Compare a hit at 'slot a'
            with hit 'slot b'.</li>
            
            <li> {@link #setBottom} This method is called by
            {@link FieldValueHitQueue} to notify the
            FieldComparator of the current weakest ("bottom")
            slot.  Note that this slot may not hold the weakest
            value according to your comparator, in cases where
            your comparator is not the primary one (ie, is only
            used to break ties from the comparators before it).</li>
            
            <li> {@link #compareBottom} Compare a new hit (docID)
            against the "weakest" (bottom) entry in the queue.</li>
            
            <li> {@link #copy} Installs a new hit into the
            priority queue.  The {@link FieldValueHitQueue}
            calls this method when a new hit is competitive.</li>
            
            <li> {@link #setNextReader} Invoked
            when the search is switching to the next segment.
            You may need to update internal state of the
            comparator, for example retrieving new values from
            the {@link FieldCache}.</li>
            
            <li> {@link #value} Return the sort value stored in
            the specified slot.  This is only called at the end
            of the search, in order to populate {@link
            FieldDoc#fields} when returning the top results.</li>
            </ul>
            
            <b>NOTE:</b> This API is experimental and might change in
            incompatible ways in the next release.
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.FieldComparator.Compare(System.Int32,System.Int32)">
            <summary> Compare hit at slot1 with hit at slot2.
            
            </summary>
            <param name="slot1">first slot to compare
            </param>
            <param name="slot2">second slot to compare
            </param>
            <returns> any N &lt; 0 if slot2's value is sorted after
            slot1, any N > 0 if the slot2's value is sorted before
            slot1 and 0 if they are equal
            </returns>
        </member>
        <member name="M:Lucene.Net.Search.FieldComparator.SetBottom(System.Int32)">
            <summary> Set the bottom slot, ie the "weakest" (sorted last)
            entry in the queue.  When {@link #compareBottom} is
            called, you should compare against this slot.  This
            will always be called before {@link #compareBottom}.
            
            </summary>
            <param name="slot">the currently weakest (sorted last) slot in the queue
            </param>
        </member>
        <member name="M:Lucene.Net.Search.FieldComparator.CompareBottom(System.Int32)">
            <summary> Compare the bottom of the queue with doc.  This will
            only invoked after setBottom has been called.  This
            should return the same result as {@link
            #Compare(int,int)}} as if bottom were slot1 and the new
            document were slot 2.
            
            <p/>For a search that hits many results, this method
            will be the hotspot (invoked by far the most
            frequently).<p/>
            
            </summary>
            <param name="doc">that was hit
            </param>
            <returns> any N &lt; 0 if the doc's value is sorted after
            the bottom entry (not competitive), any N > 0 if the
            doc's value is sorted before the bottom entry and 0 if
            they are equal.
            </returns>
        </member>
        <member name="M:Lucene.Net.Search.FieldComparator.Copy(System.Int32,System.Int32)">
            <summary> This method is called when a new hit is competitive.
            You should copy any state associated with this document
            that will be required for future comparisons, into the
            specified slot.
            
            </summary>
            <param name="slot">which slot to copy the hit to
            </param>
            <param name="doc">docID relative to current reader
            </param>
        </member>
        <member name="M:Lucene.Net.Search.FieldComparator.SetNextReader(Lucene.Net.Index.IndexReader,System.Int32)">
            <summary> Set a new Reader. All doc correspond to the current Reader.
            
            </summary>
            <param name="reader">current reader
            </param>
            <param name="docBase">docBase of this reader 
            </param>
            <throws>  IOException </throws>
            <throws>  IOException </throws>
        </member>
        <member name="M:Lucene.Net.Search.FieldComparator.SetScorer(Lucene.Net.Search.Scorer)">
            <summary>Sets the Scorer to use in case a document's score is
            needed.
            
            </summary>
            <param name="scorer">Scorer instance that you should use to
            obtain the current hit's score, if necessary. 
            </param>
        </member>
        <member name="M:Lucene.Net.Search.FieldComparator.Value(System.Int32)">
            <summary> Return the actual value in the slot.
            
            </summary>
            <param name="slot">the value
            </param>
            <returns> value in this slot upgraded to Comparable
            </returns>
        </member>
        <member name="T:Lucene.Net.Search.FieldComparator.ByteComparator">
            <summary>Parses field's values as byte (using {@link
            FieldCache#getBytes} and sorts by ascending value 
            </summary>
        </member>
        <member name="T:Lucene.Net.Search.FieldComparator.DocComparator">
            <summary>Sorts by ascending docID </summary>
        </member>
        <member name="T:Lucene.Net.Search.FieldComparator.DoubleComparator">
            <summary>Parses field's values as double (using {@link
            FieldCache#getDoubles} and sorts by ascending value 
            </summary>
        </member>
        <member name="T:Lucene.Net.Search.FieldComparator.FloatComparator">
            <summary>Parses field's values as float (using {@link
            FieldCache#getFloats} and sorts by ascending value 
            </summary>
        </member>
        <member name="T:Lucene.Net.Search.FieldComparator.IntComparator">
            <summary>Parses field's values as int (using {@link
            FieldCache#getInts} and sorts by ascending value 
            </summary>
        </member>
        <member name="T:Lucene.Net.Search.FieldComparator.LongComparator">
            <summary>Parses field's values as long (using {@link
            FieldCache#getLongs} and sorts by ascending value 
            </summary>
        </member>
        <member name="T:Lucene.Net.Search.FieldComparator.RelevanceComparator">
            <summary>Sorts by descending relevance.  NOTE: if you are
            sorting only by descending relevance and then
            secondarily by ascending docID, peformance is faster
            using {@link TopScoreDocCollector} directly (which {@link
            IndexSearcher#search} uses when no {@link Sort} is
            specified). 
            </summary>
        </member>
        <member name="T:Lucene.Net.Search.FieldComparator.ShortComparator">
            <summary>Parses field's values as short (using {@link
            FieldCache#getShorts} and sorts by ascending value 
            </summary>
        </member>
        <member name="T:Lucene.Net.Search.FieldComparator.StringComparatorLocale">
            <summary>Sorts by a field's value using the Collator for a
            given Locale.
            </summary>
        </member>
        <member name="T:Lucene.Net.Search.FieldComparator.StringOrdValComparator">
            <summary>Sorts by field's natural String sort order, using
            ordinals.  This is functionally equivalent to {@link
            StringValComparator}, but it first resolves the string
            to their relative ordinal positions (using the index
            returned by {@link FieldCache#getStringIndex}), and
            does most comparisons using the ordinals.  For medium
            to large results, this comparator will be much faster
            than {@link StringValComparator}.  For very small
            result sets it may be slower. 
            </summary>
        </member>
        <member name="T:Lucene.Net.Search.FieldComparator.StringValComparator">
            <summary>Sorts by field's natural String sort order.  All
            comparisons are done using String.compareTo, which is
            slow for medium to large result sets but possibly
            very fast for very small results sets. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.TermVectorsTermsWriterPerField.Finish">
            <summary>Called once per field per document if term vectors
            are enabled, to write the vectors to
            RAMOutputStream, which is then quickly flushed to
            the real term vectors files in the Directory. 
            </summary>
        </member>
        <member name="T:Lucene.Net.Index.SnapshotDeletionPolicy">
            <summary>A {@link IndexDeletionPolicy} that wraps around any other
            {@link IndexDeletionPolicy} and adds the ability to hold and
            later release a single "snapshot" of an index.  While
            the snapshot is held, the {@link IndexWriter} will not
            remove any files associated with it even if the index is
            otherwise being actively, arbitrarily changed.  Because
            we wrap another arbitrary {@link IndexDeletionPolicy}, this
            gives you the freedom to continue using whatever {@link
            IndexDeletionPolicy} you would normally want to use with your
            index.  Note that you can re-use a single instance of
            SnapshotDeletionPolicy across multiple writers as long
            as they are against the same index Directory.  Any
            snapshot held when a writer is closed will "survive"
            when the next writer is opened.
            
            <p/><b>WARNING</b>: This API is a new and experimental and
            may suddenly change.<p/> 
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.SnapshotDeletionPolicy.Snapshot">
            <summary>Take a snapshot of the most recent commit to the
            index.  You must call release() to free this snapshot.
            Note that while the snapshot is held, the files it
            references will not be deleted, which will consume
            additional disk space in your index. If you take a
            snapshot at a particularly bad time (say just before
            you call optimize()) then in the worst case this could
            consume an extra 1X of your total index size, until
            you release the snapshot. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.SnapshotDeletionPolicy.Release">
            <summary>Release the currently held snapshot. </summary>
        </member>
        <member name="T:Lucene.Net.Index.DirectoryReader">
            <summary> An IndexReader which reads indexes with multiple segments.</summary>
        </member>
        <member name="M:Lucene.Net.Index.DirectoryReader.#ctor(Lucene.Net.Store.Directory,Lucene.Net.Index.SegmentInfos,Lucene.Net.Index.IndexDeletionPolicy,System.Boolean,System.Int32)">
            <summary>Construct reading the named set of readers. </summary>
        </member>
        <member name="M:Lucene.Net.Index.DirectoryReader.#ctor(Lucene.Net.Store.Directory,Lucene.Net.Index.SegmentInfos,Lucene.Net.Index.SegmentReader[],System.Int32[],System.Collections.IDictionary,System.Boolean,System.Boolean,System.Int32)">
            <summary>This constructor is only used for {@link #Reopen()} </summary>
        </member>
        <member name="M:Lucene.Net.Index.DirectoryReader.GetVersion">
            <summary>Version number when this IndexReader was opened. </summary>
        </member>
        <member name="M:Lucene.Net.Index.DirectoryReader.IsOptimized">
            <summary> Checks is the index is optimized (if it has a single segment and no deletions)</summary>
            <returns> <code>true</code> if the index is optimized; <code>false</code> otherwise
            </returns>
        </member>
        <member name="M:Lucene.Net.Index.DirectoryReader.AcquireWriteLock">
            <summary> Tries to acquire the WriteLock on this directory. this method is only valid if this IndexReader is directory
            owner.
            
            </summary>
            <throws>  StaleReaderException  if the index has changed since this reader was opened </throws>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  Lucene.Net.Store.LockObtainFailedException </throws>
            <summary>                               if another writer has this index open (<code>write.lock</code> could not be
            obtained)
            </summary>
            <throws>  IOException           if there is a low-level IO error </throws>
        </member>
        <member name="M:Lucene.Net.Index.DirectoryReader.DoCommit">
            <deprecated>  
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Index.DirectoryReader.DoCommit(System.Collections.Generic.IDictionary{System.String,System.String})">
            <summary> Commit changes resulting from delete, undeleteAll, or setNorm operations
            <p/>
            If an exception is hit, then either no changes or all changes will have been committed to the index (transactional
            semantics).
            
            </summary>
            <throws>  IOException if there is a low-level IO error </throws>
        </member>
        <member name="M:Lucene.Net.Index.DirectoryReader.Directory">
            <summary>Returns the directory this index resides in. </summary>
        </member>
        <member name="M:Lucene.Net.Index.DirectoryReader.GetIndexCommit">
            <summary> Expert: return the IndexCommit that this reader has opened.
            <p/>
            <p/><b>WARNING</b>: this API is new and experimental and may suddenly change.<p/>
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.DirectoryReader.ListCommits(Lucene.Net.Store.Directory)">
            <seealso cref="!:Lucene.Net.Index.IndexReader.listCommits">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Index.DirectoryReader.MultiTermDocs.Read(System.Int32[],System.Int32[])">
            <summary>Optimized implementation. </summary>
        </member>
        <member name="T:Lucene.Net.Index.PositionBasedTermVectorMapper">
            <summary> For each Field, store position by position information.  It ignores frequency information
            <p/>
            This is not thread-safe.
            </summary>
        </member>
        <member name="F:Lucene.Net.Index.PositionBasedTermVectorMapper.currentPositions">
            <summary> A Map of Integer and TVPositionInfo</summary>
        </member>
        <member name="M:Lucene.Net.Index.PositionBasedTermVectorMapper.#ctor">
            <summary> 
            
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.PositionBasedTermVectorMapper.IsIgnoringPositions">
            <summary> Never ignores positions.  This mapper doesn't make much sense unless there are positions</summary>
            <returns> false
            </returns>
        </member>
        <member name="M:Lucene.Net.Index.PositionBasedTermVectorMapper.Map(System.String,System.Int32,Lucene.Net.Index.TermVectorOffsetInfo[],System.Int32[])">
            <summary> Callback for the TermVectorReader. </summary>
            <param name="term">
            </param>
            <param name="frequency">
            </param>
            <param name="offsets">
            </param>
            <param name="positions">
            </param>
        </member>
        <member name="M:Lucene.Net.Index.PositionBasedTermVectorMapper.SetExpectations(System.String,System.Int32,System.Boolean,System.Boolean)">
            <summary> Callback mechanism used by the TermVectorReader</summary>
            <param name="field"> The field being read
            </param>
            <param name="numTerms">The number of terms in the vector
            </param>
            <param name="storeOffsets">Whether offsets are available
            </param>
            <param name="storePositions">Whether positions are available
            </param>
        </member>
        <member name="M:Lucene.Net.Index.PositionBasedTermVectorMapper.GetFieldToTerms">
            <summary> Get the mapping between fields and terms, sorted by the comparator
            
            </summary>
            <returns> A map between field names and a Map.  The sub-Map key is the position as the integer, the value is {@link Lucene.Net.Index.PositionBasedTermVectorMapper.TVPositionInfo}.
            </returns>
        </member>
        <member name="T:Lucene.Net.Index.PositionBasedTermVectorMapper.TVPositionInfo">
            <summary> Container for a term at a position</summary>
        </member>
        <member name="P:Lucene.Net.Index.PositionBasedTermVectorMapper.TVPositionInfo.Position">
            <summary> </summary>
            <returns> The position of the term
            </returns>
        </member>
        <member name="P:Lucene.Net.Index.PositionBasedTermVectorMapper.TVPositionInfo.Terms">
            <summary> Note, there may be multiple terms at the same position</summary>
            <returns> A List of Strings
            </returns>
        </member>
        <member name="P:Lucene.Net.Index.PositionBasedTermVectorMapper.TVPositionInfo.Offsets">
            <summary> Parallel list (to {@link #getTerms()}) of TermVectorOffsetInfo objects.  There may be multiple entries since there may be multiple terms at a position</summary>
            <returns> A List of TermVectorOffsetInfo objects, if offsets are store.
            </returns>
        </member>
        <member name="T:Lucene.Net.Index.FormatPostingsDocsConsumer">
            <summary> NOTE: this API is experimental and will likely change</summary>
        </member>
        <member name="M:Lucene.Net.Index.FormatPostingsDocsConsumer.AddDoc(System.Int32,System.Int32)">
            <summary>Adds a new doc in this term.  If this returns null
            then we just skip consuming positions/payloads. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.FormatPostingsDocsConsumer.Finish">
            <summary>Called when we are done adding docs to this term </summary>
        </member>
        <member name="T:Lucene.Net.Index.DocInverterPerField">
            <summary> Holds state for inverting all occurrences of a single
            field in the document.  This class doesn't do anything
            itself; instead, it forwards the tokens produced by
            analysis to its own consumer
            (InvertedDocConsumerPerField).  It also interacts with an
            endConsumer (InvertedDocEndConsumerPerField).
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.DocConsumerPerThread.ProcessDocument">
            <summary>Process the document. If there is
            something for this document to be done in docID order,
            you should encapsulate that as a
            DocumentsWriter.DocWriter and return it.
            DocumentsWriter then calls finish() on this object
            when it's its turn. 
            </summary>
        </member>
        <member name="T:Lucene.Net.Index.AbstractAllTermDocs">
            <summary>
            Base class for enumerating all but deleted docs.
            
            <p/>NOTE: this class is meant only to be used internally
            by Lucene; it's only public so it can be shared across
            packages.  This means the API is freely subject to
            change, and, the class could be removed entirely, in any
            Lucene release.  Use directly at your own risk! */
            </summary>
        </member>
        <member name="T:Lucene.Net.Documents.LoadFirstFieldSelector">
            <summary> Load the First field and break.
            <p/>
            See {@link FieldSelectorResult#LOAD_AND_BREAK}
            </summary>
        </member>
        <member name="T:Lucene.Net.Documents.FieldSelector">
            <summary> Similar to a {@link java.io.FileFilter}, the FieldSelector allows one to make decisions about
            what Fields get loaded on a {@link Document} by {@link Lucene.Net.Index.IndexReader#Document(int,Lucene.Net.Documents.FieldSelector)}
            
            
            </summary>
        </member>
        <member name="M:Lucene.Net.Documents.FieldSelector.Accept(System.String)">
            <summary> </summary>
            <param name="fieldName">the field to accept or reject
            </param>
            <returns> an instance of {@link FieldSelectorResult}
            if the {@link Field} named <code>fieldName</code> should be loaded.
            </returns>
        </member>
        <member name="T:Lucene.Net.Analysis.WordlistLoader">
            <summary> Loader for text files that represent a list of stopwords.
            
            
            </summary>
            <version>  $Id: WordlistLoader.java 706342 2008-10-20 17:19:29Z gsingers $
            </version>
        </member>
        <member name="M:Lucene.Net.Analysis.WordlistLoader.GetWordSet(System.IO.FileInfo)">
            <summary> Loads a text file and adds every line as an entry to a HashSet (omitting
            leading and trailing whitespace). Every line of the file should contain only
            one word. The words need to be in lowercase if you make use of an
            Analyzer which uses LowerCaseFilter (like StandardAnalyzer).
            
            </summary>
            <param name="wordfile">File containing the wordlist
            </param>
            <returns> A HashSet with the file's words
            </returns>
        </member>
        <member name="M:Lucene.Net.Analysis.WordlistLoader.GetWordSet(System.IO.FileInfo,System.String)">
            <summary> Loads a text file and adds every non-comment line as an entry to a HashSet (omitting
            leading and trailing whitespace). Every line of the file should contain only
            one word. The words need to be in lowercase if you make use of an
            Analyzer which uses LowerCaseFilter (like StandardAnalyzer).
            
            </summary>
            <param name="wordfile">File containing the wordlist
            </param>
            <param name="comment">The comment string to ignore
            </param>
            <returns> A HashSet with the file's words
            </returns>
        </member>
        <member name="M:Lucene.Net.Analysis.WordlistLoader.GetWordSet(System.IO.TextReader)">
            <summary> Reads lines from a Reader and adds every line as an entry to a HashSet (omitting
            leading and trailing whitespace). Every line of the Reader should contain only
            one word. The words need to be in lowercase if you make use of an
            Analyzer which uses LowerCaseFilter (like StandardAnalyzer).
            
            </summary>
            <param name="reader">Reader containing the wordlist
            </param>
            <returns> A HashSet with the reader's words
            </returns>
        </member>
        <member name="M:Lucene.Net.Analysis.WordlistLoader.GetWordSet(System.IO.TextReader,System.String)">
            <summary> Reads lines from a Reader and adds every non-comment line as an entry to a HashSet (omitting
            leading and trailing whitespace). Every line of the Reader should contain only
            one word. The words need to be in lowercase if you make use of an
            Analyzer which uses LowerCaseFilter (like StandardAnalyzer).
            
            </summary>
            <param name="reader">Reader containing the wordlist
            </param>
            <param name="comment">The string representing a comment.
            </param>
            <returns> A HashSet with the reader's words
            </returns>
        </member>
        <member name="M:Lucene.Net.Analysis.WordlistLoader.GetStemDict(System.IO.FileInfo)">
            <summary> Reads a stem dictionary. Each line contains:
            <pre>word<b>\t</b>stem</pre>
            (i.e. two tab seperated words)
            
            </summary>
            <returns> stem dictionary that overrules the stemming algorithm
            </returns>
            <throws>  IOException  </throws>
        </member>
        <member name="T:Lucene.Net.Store.FileSwitchDirectory">
            <summary> Expert: A Directory instance that switches files between
            two other Directory instances.
            <p/>Files with the specified extensions are placed in the
            primary directory; others are placed in the secondary
            directory.  The provided Set must not change once passed
            to this class, and must allow multiple threads to call
            contains at once.<p/>
            
            <p/><b>NOTE</b>: this API is new and experimental and is
            subject to suddenly change in the next release.
            </summary>
        </member>
        <member name="M:Lucene.Net.Store.FileSwitchDirectory.GetPrimaryDir">
            <summary>Return the primary directory </summary>
        </member>
        <member name="M:Lucene.Net.Store.FileSwitchDirectory.GetSecondaryDir">
            <summary>Return the secondary directory </summary>
        </member>
        <member name="M:Lucene.Net.Store.FileSwitchDirectory.Dispose">
            <summary>
            .NET
            </summary>
        </member>
        <member name="M:Lucene.Net.Store.FileSwitchDirectory.GetExtension(System.String)">
            <summary>Utility method to return a file's extension. </summary>
        </member>
        <member name="T:Lucene.Net.Search.TopFieldCollector">
            <summary> A {@link Collector} that sorts by {@link SortField} using
            {@link FieldComparator}s.
            <p/>
            See the {@link #create(Lucene.Net.Search.Sort, int, boolean, boolean, boolean, boolean)} method
            for instantiating a TopFieldCollector.
            
            <p/><b>NOTE:</b> This API is experimental and might change in
            incompatible ways in the next release.<p/>
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.TopFieldCollector.create(Lucene.Net.Search.Sort,System.Int32,System.Boolean,System.Boolean,System.Boolean,System.Boolean)">
            <summary> Creates a new {@link TopFieldCollector} from the given
            arguments.
            
            <p/><b>NOTE</b>: The instances returned by this method
            pre-allocate a full array of length
            <code>numHits</code>.
            
            </summary>
            <param name="sort">the sort criteria (SortFields).
            </param>
            <param name="numHits">the number of results to collect.
            </param>
            <param name="fillFields">specifies whether the actual field values should be returned on
            the results (FieldDoc).
            </param>
            <param name="trackDocScores">specifies whether document scores should be tracked and set on the
            results. Note that if set to false, then the results' scores will
            be set to Float.NaN. Setting this to true affects performance, as
            it incurs the score computation on each competitive result.
            Therefore if document scores are not required by the application,
            it is recommended to set it to false.
            </param>
            <param name="trackMaxScore">specifies whether the query's maxScore should be tracked and set
            on the resulting {@link TopDocs}. Note that if set to false,
            {@link TopDocs#GetMaxScore()} returns Float.NaN. Setting this to
            true affects performance as it incurs the score computation on
            each result. Also, setting this true automatically sets
            <code>trackDocScores</code> to true as well.
            </param>
            <param name="docsScoredInOrder">specifies whether documents are scored in doc Id order or not by
            the given {@link Scorer} in {@link #SetScorer(Scorer)}.
            </param>
            <returns> a {@link TopFieldCollector} instance which will sort the results by
            the sort criteria.
            </returns>
            <throws>  IOException </throws>
        </member>
        <member name="T:Lucene.Net.Search.QueryWrapperFilter">
            <summary> Constrains search results to only match those which also match a provided
            query.  
            
            <p/> This could be used, for example, with a {@link TermRangeQuery} on a suitably
            formatted date field to implement date filtering.  One could re-use a single
            QueryFilter that matches, e.g., only documents modified within the last
            week.  The QueryFilter and TermRangeQuery would only need to be reconstructed
            once per day.
            
            </summary>
            <version>  $Id:$
            </version>
        </member>
        <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.QueryWrapperFilter.Bits(Lucene.Net.Index.IndexReader)">
            <deprecated> Use {@link #GetDocIdSet(IndexReader)} instead.
            </deprecated>
        </member>
        <member name="T:Lucene.Net.Search.DisjunctionSumScorer">
            <summary>A Scorer for OR like queries, counterpart of <code>ConjunctionScorer</code>.
            This Scorer implements {@link Scorer#SkipTo(int)} and uses skipTo() on the given Scorers. 
            TODO: Implement score(HitCollector, int).
            </summary>
        </member>
        <member name="F:Lucene.Net.Search.DisjunctionSumScorer.nrScorers">
            <summary>The number of subscorers. </summary>
        </member>
        <member name="F:Lucene.Net.Search.DisjunctionSumScorer.subScorers">
            <summary>The subscorers. </summary>
        </member>
        <member name="F:Lucene.Net.Search.DisjunctionSumScorer.minimumNrMatchers">
            <summary>The minimum number of scorers that should match. </summary>
        </member>
        <member name="F:Lucene.Net.Search.DisjunctionSumScorer.scorerDocQueue">
            <summary>The scorerDocQueue contains all subscorers ordered by their current doc(),
            with the minimum at the top.
            <br/>The scorerDocQueue is initialized the first time next() or skipTo() is called.
            <br/>An exhausted scorer is immediately removed from the scorerDocQueue.
            <br/>If less than the minimumNrMatchers scorers
            remain in the scorerDocQueue next() and skipTo() return false.
            <p/>
            After each to call to next() or skipTo()
            <code>currentSumScore</code> is the total score of the current matching doc,
            <code>nrMatchers</code> is the number of matching scorers,
            and all scorers are after the matching doc, or are exhausted.
            </summary>
        </member>
        <member name="F:Lucene.Net.Search.DisjunctionSumScorer.currentDoc">
            <summary>The document number of the current match. </summary>
        </member>
        <member name="F:Lucene.Net.Search.DisjunctionSumScorer.nrMatchers">
            <summary>The number of subscorers that provide the current match. </summary>
        </member>
        <member name="M:Lucene.Net.Search.DisjunctionSumScorer.#ctor(System.Collections.IList,System.Int32)">
            <summary>Construct a <code>DisjunctionScorer</code>.</summary>
            <param name="subScorers">A collection of at least two subscorers.
            </param>
            <param name="minimumNrMatchers">The positive minimum number of subscorers that should
            match to match this query.
            <br/>When <code>minimumNrMatchers</code> is bigger than
            the number of <code>subScorers</code>,
            no matches will be produced.
            <br/>When minimumNrMatchers equals the number of subScorers,
            it more efficient to use <code>ConjunctionScorer</code>.
            </param>
        </member>
        <member name="M:Lucene.Net.Search.DisjunctionSumScorer.#ctor(System.Collections.IList)">
            <summary>Construct a <code>DisjunctionScorer</code>, using one as the minimum number
            of matching subscorers.
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.DisjunctionSumScorer.InitScorerDocQueue">
            <summary>Called the first time next() or skipTo() is called to
            initialize <code>scorerDocQueue</code>.
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.DisjunctionSumScorer.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.DisjunctionSumScorer.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 through.
            <br/>When this method is used the {@link #Explain(int)} method should not be used.
            </param>
        </member>
        <member name="M:Lucene.Net.Search.DisjunctionSumScorer.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>
        <member name="M:Lucene.Net.Search.DisjunctionSumScorer.Score(Lucene.Net.Search.Collector,System.Int32,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="collector">The collector to which all matching documents are passed through.
            </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.DisjunctionSumScorer.Next">
            <deprecated> use {@link #NextDoc()} instead. 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.DisjunctionSumScorer.AdvanceAfterCurrent">
            <summary>Advance all subscorers after the current document determined by the
            top of the <code>scorerDocQueue</code>.
            Repeat until at least the minimum number of subscorers match on the same
            document and all subscorers are after that document or are exhausted.
            <br/>On entry the <code>scorerDocQueue</code> has at least <code>minimumNrMatchers</code>
            available. At least the scorer with the minimum document number will be advanced.
            </summary>
            <returns> true iff there is a match.
            <br/>In case there is a match, <code>currentDoc</code>, <code>currentSumScore</code>,
            and <code>nrMatchers</code> describe the match.
            
            TODO: Investigate whether it is possible to use skipTo() when
            the minimum number of matchers is bigger than one, ie. try and use the
            character of ConjunctionScorer for the minimum number of matchers.
            Also delay calling score() on the sub scorers until the minimum number of
            matchers is reached.
            <br/>For this, a Scorer array with minimumNrMatchers elements might
            hold Scorers at currentDoc that are temporarily popped from scorerQueue.
            </returns>
        </member>
        <member name="M:Lucene.Net.Search.DisjunctionSumScorer.Score">
            <summary>Returns the score of the current document matching the query.
            Initially invalid, until {@link #Next()} is called the first time.
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.DisjunctionSumScorer.Doc">
            <deprecated> use {@link #DocID()} instead. 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.DisjunctionSumScorer.NrMatchers">
            <summary>Returns the number of subscorers matching the current document.
            Initially invalid, until {@link #Next()} is called the first time.
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.DisjunctionSumScorer.SkipTo(System.Int32)">
            <summary> Skips to the first match beyond the current whose document number is
            greater than or equal to a given target. <br/>
            When this method is used the {@link #Explain(int)} method should not be
            used. <br/>
            The implementation uses the skipTo() method on the subscorers.
            
            </summary>
            <param name="target">The target document number.
            </param>
            <returns> true iff there is such a match.
            </returns>
            <deprecated> use {@link #Advance(int)} instead.
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.DisjunctionSumScorer.Advance(System.Int32)">
            <summary> Advances to the first match beyond the current whose document number is
            greater than or equal to a given target. <br/>
            When this method is used the {@link #Explain(int)} method should not be
            used. <br/>
            The implementation uses the skipTo() method on the subscorers.
            
            </summary>
            <param name="target">The target document number.
            </param>
            <returns> the document whose number is greater than or equal to the given
            target, or -1 if none exist.
            </returns>
        </member>
        <member name="M:Lucene.Net.Search.DisjunctionSumScorer.Explain(System.Int32)">
            <returns> An explanation for the score of a given document. 
            </returns>
        </member>
        <member name="T:Lucene.Net.Search.BooleanScorer2">
            <summary>An alternative to BooleanScorer that also allows a minimum number
            of optional scorers that should match.
            <br/>Implements skipTo(), and has no limitations on the numbers of added scorers.
            <br/>Uses ConjunctionScorer, DisjunctionScorer, ReqOptScorer and ReqExclScorer.
            </summary>
        </member>
        <member name="F:Lucene.Net.Search.BooleanScorer2.countingSumScorer">
            <summary>The scorer to which all scoring will be delegated,
            except for computing and using the coordination factor.
            </summary>
        </member>
        <member name="F:Lucene.Net.Search.BooleanScorer2.minNrShouldMatch">
            <summary>The number of optionalScorers that need to match (if there are any) </summary>
        </member>
        <member name="M:Lucene.Net.Search.BooleanScorer2.#ctor(Lucene.Net.Search.Similarity,System.Int32,System.Collections.IList,System.Collections.IList,System.Collections.IList)">
            <summary> Creates a {@link Scorer} with the given similarity and lists of required,
            prohibited and optional scorers. In no required scorers are added, at least
            one of the optional scorers will have to match during the search.
            
            </summary>
            <param name="similarity">The similarity to be used.
            </param>
            <param name="minNrShouldMatch">The minimum number of optional added scorers that should match
            during the search. In case no required scorers are added, at least
            one of the optional scorers will have to match during the search.
            </param>
            <param name="required">the list of required scorers.
            </param>
            <param name="prohibited">the list of prohibited scorers.
            </param>
            <param name="optional">the list of optional scorers.
            </param>
        </member>
        <member name="M:Lucene.Net.Search.BooleanScorer2.MakeCountingSumScorer">
            <summary>Returns the scorer to be used for match counting and score summing.
            Uses requiredScorers, optionalScorers and prohibitedScorers.
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.BooleanScorer2.AddProhibitedScorers(Lucene.Net.Search.Scorer)">
            <summary>Returns the scorer to be used for match counting and score summing.
            Uses the given required scorer and the prohibitedScorers.
            </summary>
            <param name="requiredCountingSumScorer">A required scorer already built.
            </param>
        </member>
        <member name="M:Lucene.Net.Search.BooleanScorer2.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.BooleanScorer2.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 through.
            <br/>When this method is used the {@link #Explain(int)} method should not be used.
            </param>
        </member>
        <member name="M:Lucene.Net.Search.BooleanScorer2.Score(Lucene.Net.Search.HitCollector,System.Int32)">
            <summary>Expert: Collects matching documents in a range.
            <br/>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>
        <member name="M:Lucene.Net.Search.BooleanScorer2.Doc">
            <deprecated> use {@link #DocID()} instead. 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.BooleanScorer2.Next">
            <deprecated> use {@link #NextDoc()} instead. 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.BooleanScorer2.SkipTo(System.Int32)">
            <deprecated> use {@link #Advance(int)} instead. 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.BooleanScorer2.Explain(System.Int32)">
            <summary>Throws an UnsupportedOperationException.
            TODO: Implement an explanation of the coordination factor.
            </summary>
            <param name="doc">The document number for the explanation.
            </param>
            <throws>  UnsupportedOperationException </throws>
        </member>
        <member name="T:Lucene.Net.Search.ConjunctionScorer">
            <summary>Scorer for conjunctions, sets of queries, all of which are required. </summary>
        </member>
        <member name="M:Lucene.Net.Search.ConjunctionScorer.Doc">
            <deprecated> use {@link #DocID()} instead. 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.ConjunctionScorer.Next">
            <deprecated> use {@link #NextDoc()} instead. 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.ConjunctionScorer.SkipTo(System.Int32)">
            <deprecated> use {@link #Advance(int)} instead. 
            </deprecated>
        </member>
        <member name="T:Lucene.Net.Search.BooleanScorer2.SingleMatchScorer">
            <summary>Count a scorer as a single match. </summary>
        </member>
        <member name="M:Lucene.Net.Search.BooleanScorer2.SingleMatchScorer.Doc">
            <deprecated> use {@link #DocID()} instead. 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.BooleanScorer2.SingleMatchScorer.Next">
            <deprecated> use {@link #NextDoc()} instead. 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.BooleanScorer2.SingleMatchScorer.SkipTo(System.Int32)">
            <deprecated> use {@link #Advance(int)} instead. 
            </deprecated>
        </member>
        <member name="T:Lucene.Net.QueryParsers.QueryParser">
            <summary> This class is generated by JavaCC.  The most important method is
            {@link #Parse(String)}.
            
            The syntax for query strings is as follows:
            A Query is a series of clauses.
            A clause may be prefixed by:
            <ul>
            <li> a plus (<code>+</code>) or a minus (<code>-</code>) sign, indicating
            that the clause is required or prohibited respectively; or</li>
            <li> a term followed by a colon, indicating the field to be searched.
            This enables one to construct queries which search multiple fields.</li>
            </ul>
            
            A clause may be either:
            <ul>
            <li> a term, indicating all the documents that contain this term; or</li>
            <li> a nested query, enclosed in parentheses.  Note that this may be used
            with a <code>+</code>/<code>-</code> prefix to require any of a set of
            terms.</li>
            </ul>
            
            Thus, in BNF, the query grammar is:
            <pre>
            Query  ::= ( Clause )*
            Clause ::= ["+", "-"] [&lt;TERM&gt; ":"] ( &lt;TERM&gt; | "(" Query ")" )
            </pre>
            
            <p/>
            Examples of appropriately formatted queries can be found in the <a
            href="../../../../../../queryparsersyntax.html">query syntax
            documentation</a>.
            <p/>
            
            <p/>
            In {@link TermRangeQuery}s, QueryParser tries to detect date values, e.g.
            <tt>date:[6/1/2005 TO 6/4/2005]</tt> produces a range query that searches
            for "date" fields between 2005-06-01 and 2005-06-04. Note that the format
            of the accepted input depends on {@link #SetLocale(Locale) the locale}.
            By default a date is converted into a search term using the deprecated
            {@link DateField} for compatibility reasons.
            To use the new {@link DateTools} to convert dates, a
            {@link Lucene.Net.Documents.DateTools.Resolution} has to be set.
            <p/>
            <p/>
            The date resolution that shall be used for RangeQueries can be set
            using {@link #SetDateResolution(DateTools.Resolution)}
            or {@link #SetDateResolution(String, DateTools.Resolution)}. The former
            sets the default date resolution for all fields, whereas the latter can
            be used to set field specific date resolutions. Field specific date
            resolutions take, if set, precedence over the default date resolution.
            <p/>
            <p/>
            If you use neither {@link DateField} nor {@link DateTools} in your
            index, you can create your own
            query parser that inherits QueryParser and overwrites
            {@link #GetRangeQuery(String, String, String, boolean)} to
            use a different method for date conversion.
            <p/>
            
            <p/>Note that QueryParser is <em>not</em> thread-safe.<p/> 
            
            <p/><b>NOTE</b>: there is a new QueryParser in contrib, which matches
            the same syntax as this class, but is more modular,
            enabling substantial customization to how a query is created.
            
            <p/><b>NOTE</b>: there is a new QueryParser in contrib, which matches
            the same syntax as this class, but is more modular,
            enabling substantial customization to how a query is created.
            <b>NOTE</b>: You must specify the required {@link Version} compatibility when
            creating QueryParser:
            <ul>
            <li>As of 2.9, {@link #SetEnablePositionIncrements} is true by default.</li>
            </ul>
            </summary>
        </member>
        <member name="T:Lucene.Net.QueryParsers.QueryParserConstants">
            <summary> Token literal values and constants.
            Generated by org.javacc.parser.OtherFilesGen#start()
            </summary>
        </member>
        <member name="F:Lucene.Net.QueryParsers.QueryParserConstants.EOF">
            <summary>End of File. </summary>
        </member>
        <member name="F:Lucene.Net.QueryParsers.QueryParserConstants._NUM_CHAR">
            <summary>RegularExpression Id. </summary>
        </member>
        <member name="F:Lucene.Net.QueryParsers.QueryParserConstants._ESCAPED_CHAR">
            <summary>RegularExpression Id. </summary>
        </member>
        <member name="F:Lucene.Net.QueryParsers.QueryParserConstants._TERM_START_CHAR">
            <summary>RegularExpression Id. </summary>
        </member>
        <member name="F:Lucene.Net.QueryParsers.QueryParserConstants._TERM_CHAR">
            <summary>RegularExpression Id. </summary>
        </member>
        <member name="F:Lucene.Net.QueryParsers.QueryParserConstants._WHITESPACE">
            <summary>RegularExpression Id. </summary>
        </member>
        <member name="F:Lucene.Net.QueryParsers.QueryParserConstants._QUOTED_CHAR">
            <summary>RegularExpression Id. </summary>
        </member>
        <member name="F:Lucene.Net.QueryParsers.QueryParserConstants.AND">
            <summary>RegularExpression Id. </summary>
        </member>
        <member name="F:Lucene.Net.QueryParsers.QueryParserConstants.OR">
            <summary>RegularExpression Id. </summary>
        </member>
        <member name="F:Lucene.Net.QueryParsers.QueryParserConstants.NOT">
            <summary>RegularExpression Id. </summary>
        </member>
        <member name="F:Lucene.Net.QueryParsers.QueryParserConstants.PLUS">
            <summary>RegularExpression Id. </summary>
        </member>
        <member name="F:Lucene.Net.QueryParsers.QueryParserConstants.MINUS">
            <summary>RegularExpression Id. </summary>
        </member>
        <member name="F:Lucene.Net.QueryParsers.QueryParserConstants.LPAREN">
            <summary>RegularExpression Id. </summary>
        </member>
        <member name="F:Lucene.Net.QueryParsers.QueryParserConstants.RPAREN">
            <summary>RegularExpression Id. </summary>
        </member>
        <member name="F:Lucene.Net.QueryParsers.QueryParserConstants.COLON">
            <summary>RegularExpression Id. </summary>
        </member>
        <member name="F:Lucene.Net.QueryParsers.QueryParserConstants.STAR">
            <summary>RegularExpression Id. </summary>
        </member>
        <member name="F:Lucene.Net.QueryParsers.QueryParserConstants.CARAT">
            <summary>RegularExpression Id. </summary>
        </member>
        <member name="F:Lucene.Net.QueryParsers.QueryParserConstants.QUOTED">
            <summary>RegularExpression Id. </summary>
        </member>
        <member name="F:Lucene.Net.QueryParsers.QueryParserConstants.TERM">
            <summary>RegularExpression Id. </summary>
        </member>
        <member name="F:Lucene.Net.QueryParsers.QueryParserConstants.FUZZY_SLOP">
            <summary>RegularExpression Id. </summary>
        </member>
        <member name="F:Lucene.Net.QueryParsers.QueryParserConstants.PREFIXTERM">
            <summary>RegularExpression Id. </summary>
        </member>
        <member name="F:Lucene.Net.QueryParsers.QueryParserConstants.WILDTERM">
            <summary>RegularExpression Id. </summary>
        </member>
        <member name="F:Lucene.Net.QueryParsers.QueryParserConstants.RANGEIN_START">
            <summary>RegularExpression Id. </summary>
        </member>
        <member name="F:Lucene.Net.QueryParsers.QueryParserConstants.RANGEEX_START">
            <summary>RegularExpression Id. </summary>
        </member>
        <member name="F:Lucene.Net.QueryParsers.QueryParserConstants.NUMBER">
            <summary>RegularExpression Id. </summary>
        </member>
        <member name="F:Lucene.Net.QueryParsers.QueryParserConstants.RANGEIN_TO">
            <summary>RegularExpression Id. </summary>
        </member>
        <member name="F:Lucene.Net.QueryParsers.QueryParserConstants.RANGEIN_END">
            <summary>RegularExpression Id. </summary>
        </member>
        <member name="F:Lucene.Net.QueryParsers.QueryParserConstants.RANGEIN_QUOTED">
            <summary>RegularExpression Id. </summary>
        </member>
        <member name="F:Lucene.Net.QueryParsers.QueryParserConstants.RANGEIN_GOOP">
            <summary>RegularExpression Id. </summary>
        </member>
        <member name="F:Lucene.Net.QueryParsers.QueryParserConstants.RANGEEX_TO">
            <summary>RegularExpression Id. </summary>
        </member>
        <member name="F:Lucene.Net.QueryParsers.QueryParserConstants.RANGEEX_END">
            <summary>RegularExpression Id. </summary>
        </member>
        <member name="F:Lucene.Net.QueryParsers.QueryParserConstants.RANGEEX_QUOTED">
            <summary>RegularExpression Id. </summary>
        </member>
        <member name="F:Lucene.Net.QueryParsers.QueryParserConstants.RANGEEX_GOOP">
            <summary>RegularExpression Id. </summary>
        </member>
        <member name="F:Lucene.Net.QueryParsers.QueryParserConstants.Boost">
            <summary>Lexical state. </summary>
        </member>
        <member name="F:Lucene.Net.QueryParsers.QueryParserConstants.RangeEx">
            <summary>Lexical state. </summary>
        </member>
        <member name="F:Lucene.Net.QueryParsers.QueryParserConstants.RangeIn">
            <summary>Lexical state. </summary>
        </member>
        <member name="F:Lucene.Net.QueryParsers.QueryParserConstants.DEFAULT">
            <summary>Lexical state. </summary>
        </member>
        <member name="F:Lucene.Net.QueryParsers.QueryParserConstants.tokenImage">
            <summary>Literal token values. </summary>
        </member>
        <member name="F:Lucene.Net.QueryParsers.QueryParser.AND_OPERATOR">
            <summary>Alternative form of QueryParser.Operator.AND </summary>
        </member>
        <member name="F:Lucene.Net.QueryParsers.QueryParser.OR_OPERATOR">
            <summary>Alternative form of QueryParser.Operator.OR </summary>
        </member>
        <member name="F:Lucene.Net.QueryParsers.QueryParser.operator_Renamed">
            <summary>The actual operator that parser uses to combine query terms </summary>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.#ctor(System.String,Lucene.Net.Analysis.Analyzer)">
            <summary>Constructs a query parser.</summary>
            <param name="f"> the default field for query terms.
            </param>
            <param name="a">  used to find terms in the query text.
            </param>
            <deprecated> Use {@link #QueryParser(Version, String, Analyzer)} instead
            </deprecated>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.#ctor(Lucene.Net.Util.Version,System.String,Lucene.Net.Analysis.Analyzer)">
            <summary> Constructs a query parser.
            
            </summary>
            <param name="matchVersion">Lucene version to match. See <a href="#version">above</a>)
            </param>
            <param name="f">the default field for query terms.
            </param>
            <param name="a">used to find terms in the query text.
            </param>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.Parse(System.String)">
            <summary>Parses a query string, returning a {@link Lucene.Net.Search.Query}.</summary>
            <param name="query"> the query string to be parsed.
            </param>
            <throws>  ParseException if the parsing fails </throws>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.GetAnalyzer">
            <returns> Returns the analyzer.
            </returns>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.GetField">
            <returns> Returns the field.
            </returns>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.GetFuzzyMinSim">
            <summary> Get the minimal similarity for fuzzy queries.</summary>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.SetFuzzyMinSim(System.Single)">
            <summary> Set the minimum similarity for fuzzy queries.
            Default is 0.5f.
            </summary>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.GetFuzzyPrefixLength">
            <summary> Get the prefix length for fuzzy queries. </summary>
            <returns> Returns the fuzzyPrefixLength.
            </returns>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.SetFuzzyPrefixLength(System.Int32)">
            <summary> Set the prefix length for fuzzy queries. Default is 0.</summary>
            <param name="fuzzyPrefixLength">The fuzzyPrefixLength to set.
            </param>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.SetPhraseSlop(System.Int32)">
            <summary> Sets the default slop for phrases.  If zero, then exact phrase matches
            are required.  Default value is zero.
            </summary>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.GetPhraseSlop">
            <summary> Gets the default slop for phrases.</summary>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.SetAllowLeadingWildcard(System.Boolean)">
            <summary> Set to <code>true</code> to allow leading wildcard characters.
            <p/>
            When set, <code>*</code> or <code>?</code> are allowed as 
            the first character of a PrefixQuery and WildcardQuery.
            Note that this can produce very slow
            queries on big indexes. 
            <p/>
            Default: false.
            </summary>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.GetAllowLeadingWildcard">
            <seealso cref="!:SetAllowLeadingWildcard(boolean)">
            </seealso>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.SetEnablePositionIncrements(System.Boolean)">
            <summary> Set to <code>true</code> to enable position increments in result query.
            <p/>
            When set, result phrase and multi-phrase queries will
            be aware of position increments.
            Useful when e.g. a StopFilter increases the position increment of
            the token that follows an omitted token.
            <p/>
            Default: false.
            </summary>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.GetEnablePositionIncrements">
            <seealso cref="!:SetEnablePositionIncrements(boolean)">
            </seealso>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.SetDefaultOperator(Lucene.Net.QueryParsers.QueryParser.Operator)">
            <summary> Sets the boolean operator of the QueryParser.
            In default mode (<code>OR_OPERATOR</code>) terms without any modifiers
            are considered optional: for example <code>capital of Hungary</code> is equal to
            <code>capital OR of OR Hungary</code>.<br/>
            In <code>AND_OPERATOR</code> mode terms are considered to be in conjunction: the
            above mentioned query is parsed as <code>capital AND of AND Hungary</code>
            </summary>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.GetDefaultOperator">
            <summary> Gets implicit operator setting, which will be either AND_OPERATOR
            or OR_OPERATOR.
            </summary>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.SetLowercaseExpandedTerms(System.Boolean)">
            <summary> Whether terms of wildcard, prefix, fuzzy and range queries are to be automatically
            lower-cased or not.  Default is <code>true</code>.
            </summary>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.GetLowercaseExpandedTerms">
            <seealso cref="!:SetLowercaseExpandedTerms(boolean)">
            </seealso>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.SetUseOldRangeQuery(System.Boolean)">
            <deprecated> Please use {@link #setMultiTermRewriteMethod} instead.
            </deprecated>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.GetUseOldRangeQuery">
            <deprecated> Please use {@link #getMultiTermRewriteMethod} instead.
            </deprecated>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.SetMultiTermRewriteMethod(Lucene.Net.Search.MultiTermQuery.RewriteMethod)">
            <summary> By default QueryParser uses {@link MultiTermQuery#CONSTANT_SCORE_AUTO_REWRITE_DEFAULT}
            when creating a PrefixQuery, WildcardQuery or RangeQuery. This implementation is generally preferable because it 
            a) Runs faster b) Does not have the scarcity of terms unduly influence score 
            c) avoids any "TooManyBooleanClauses" exception.
            However, if your application really needs to use the
            old-fashioned BooleanQuery expansion rewriting and the above
            points are not relevant then use this to change
            the rewrite method.
            </summary>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.GetMultiTermRewriteMethod">
            <seealso cref="!:setMultiTermRewriteMethod">
            </seealso>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.SetLocale(System.Globalization.CultureInfo)">
            <summary> Set locale used by date range parsing.</summary>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.GetLocale">
            <summary> Returns current locale, allowing access by subclasses.</summary>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.SetDateResolution(Lucene.Net.Documents.DateTools.Resolution)">
            <summary> Sets the default date resolution used by RangeQueries for fields for which no
            specific date resolutions has been set. Field specific resolutions can be set
            with {@link #SetDateResolution(String, DateTools.Resolution)}.
            
            </summary>
            <param name="dateResolution">the default date resolution to set
            </param>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.SetDateResolution(System.String,Lucene.Net.Documents.DateTools.Resolution)">
            <summary> Sets the date resolution used by RangeQueries for a specific field.
            
            </summary>
            <param name="fieldName">field for which the date resolution is to be set 
            </param>
            <param name="dateResolution">date resolution to set
            </param>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.GetDateResolution(System.String)">
            <summary> Returns the date resolution that is used by RangeQueries for the given field. 
            Returns null, if no default or field specific date resolution has been set
            for the given field.
            
            </summary>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.SetRangeCollator(System.Globalization.CompareInfo)">
            <summary> Sets the collator used to determine index term inclusion in ranges
            for RangeQuerys.
            <p/>
            <strong>WARNING:</strong> Setting the rangeCollator to a non-null
            collator using this method will cause every single index Term in the
            Field referenced by lowerTerm and/or upperTerm to be examined.
            Depending on the number of index Terms in this Field, the operation could
            be very slow.
            
            </summary>
            <param name="rc"> the collator to use when constructing RangeQuerys
            </param>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.GetRangeCollator">
            <returns> the collator used to determine index term inclusion in ranges
            for RangeQuerys.
            </returns>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.AddClause(System.Collections.ArrayList,System.Int32,System.Int32,Lucene.Net.Search.Query)">
            <deprecated> use {@link #AddClause(List, int, int, Query)} instead.
            </deprecated>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.GetFieldQuery(System.String,System.String)">
            <exception cref="T:Lucene.Net.QueryParsers.ParseException">throw in overridden method to disallow
            </exception>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.GetFieldQuery(System.String,System.String,System.Int32)">
            <summary> Base implementation delegates to {@link #GetFieldQuery(String,String)}.
            This method may be overridden, for example, to return
            a SpanNearQuery instead of a PhraseQuery.
            
            </summary>
            <exception cref="T:Lucene.Net.QueryParsers.ParseException">throw in overridden method to disallow
            </exception>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.GetRangeQuery(System.String,System.String,System.String,System.Boolean)">
            <exception cref="T:Lucene.Net.QueryParsers.ParseException">throw in overridden method to disallow
            </exception>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.NewBooleanQuery(System.Boolean)">
            <summary> Builds a new BooleanQuery instance</summary>
            <param name="disableCoord">disable coord
            </param>
            <returns> new BooleanQuery instance
            </returns>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.NewBooleanClause(Lucene.Net.Search.Query,Lucene.Net.Search.BooleanClause.Occur)">
            <summary> Builds a new BooleanClause instance</summary>
            <param name="q">sub query
            </param>
            <param name="occur">how this clause should occur when matching documents
            </param>
            <returns> new BooleanClause instance
            </returns>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.NewTermQuery(Lucene.Net.Index.Term)">
            <summary> Builds a new TermQuery instance</summary>
            <param name="term">term
            </param>
            <returns> new TermQuery instance
            </returns>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.NewPhraseQuery">
            <summary> Builds a new PhraseQuery instance</summary>
            <returns> new PhraseQuery instance
            </returns>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.NewMultiPhraseQuery">
            <summary> Builds a new MultiPhraseQuery instance</summary>
            <returns> new MultiPhraseQuery instance
            </returns>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.NewPrefixQuery(Lucene.Net.Index.Term)">
            <summary> Builds a new PrefixQuery instance</summary>
            <param name="prefix">Prefix term
            </param>
            <returns> new PrefixQuery instance
            </returns>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.NewFuzzyQuery(Lucene.Net.Index.Term,System.Single,System.Int32)">
            <summary> Builds a new FuzzyQuery instance</summary>
            <param name="term">Term
            </param>
            <param name="minimumSimilarity">minimum similarity
            </param>
            <param name="prefixLength">prefix length
            </param>
            <returns> new FuzzyQuery Instance
            </returns>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.NewRangeQuery(System.String,System.String,System.String,System.Boolean)">
            <summary> Builds a new TermRangeQuery instance</summary>
            <param name="field">Field
            </param>
            <param name="part1">min
            </param>
            <param name="part2">max
            </param>
            <param name="inclusive">true if range is inclusive
            </param>
            <returns> new TermRangeQuery instance
            </returns>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.NewMatchAllDocsQuery">
            <summary> Builds a new MatchAllDocsQuery instance</summary>
            <returns> new MatchAllDocsQuery instance
            </returns>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.NewWildcardQuery(Lucene.Net.Index.Term)">
            <summary> Builds a new WildcardQuery instance</summary>
            <param name="t">wildcard term
            </param>
            <returns> new WildcardQuery instance
            </returns>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.GetBooleanQuery(System.Collections.ArrayList)">
            <summary> Factory method for generating query, given a set of clauses.
            By default creates a boolean query composed of clauses passed in.
            
            Can be overridden by extending classes, to modify query being
            returned.
            
            </summary>
            <param name="clauses">List that contains {@link BooleanClause} instances
            to join.
            
            </param>
            <returns> Resulting {@link Query} object.
            </returns>
            <exception cref="T:Lucene.Net.QueryParsers.ParseException">throw in overridden method to disallow
            </exception>
            <deprecated> use {@link #GetBooleanQuery(List)} instead
            </deprecated>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.GetBooleanQuery(System.Collections.IList)">
            <summary> Factory method for generating query, given a set of clauses.
            By default creates a boolean query composed of clauses passed in.
            
            Can be overridden by extending classes, to modify query being
            returned.
            
            </summary>
            <param name="clauses">List that contains {@link BooleanClause} instances
            to join.
            
            </param>
            <returns> Resulting {@link Query} object.
            </returns>
            <exception cref="T:Lucene.Net.QueryParsers.ParseException">throw in overridden method to disallow
            </exception>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.GetBooleanQuery(System.Collections.ArrayList,System.Boolean)">
            <summary> Factory method for generating query, given a set of clauses.
            By default creates a boolean query composed of clauses passed in.
            
            Can be overridden by extending classes, to modify query being
            returned.
            
            </summary>
            <param name="clauses">List that contains {@link BooleanClause} instances
            to join.
            </param>
            <param name="disableCoord">true if coord scoring should be disabled.
            
            </param>
            <returns> Resulting {@link Query} object.
            </returns>
            <exception cref="T:Lucene.Net.QueryParsers.ParseException">throw in overridden method to disallow
            </exception>
            <deprecated> use {@link #GetBooleanQuery(List, boolean)} instead
            </deprecated>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.GetBooleanQuery(System.Collections.IList,System.Boolean)">
            <summary> Factory method for generating query, given a set of clauses.
            By default creates a boolean query composed of clauses passed in.
            
            Can be overridden by extending classes, to modify query being
            returned.
            
            </summary>
            <param name="clauses">List that contains {@link BooleanClause} instances
            to join.
            </param>
            <param name="disableCoord">true if coord scoring should be disabled.
            
            </param>
            <returns> Resulting {@link Query} object.
            </returns>
            <exception cref="T:Lucene.Net.QueryParsers.ParseException">throw in overridden method to disallow
            </exception>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.GetWildcardQuery(System.String,System.String)">
            <summary> Factory method for generating a query. Called when parser
            parses an input term token that contains one or more wildcard
            characters (? and *), but is not a prefix term token (one
            that has just a single * character at the end)
            <p/>
            Depending on settings, prefix term may be lower-cased
            automatically. It will not go through the default Analyzer,
            however, since normal Analyzers are unlikely to work properly
            with wildcard templates.
            <p/>
            Can be overridden by extending classes, to provide custom handling for
            wildcard queries, which may be necessary due to missing analyzer calls.
            
            </summary>
            <param name="field">Name of the field query will use.
            </param>
            <param name="termStr">Term token that contains one or more wild card
            characters (? or *), but is not simple prefix term
            
            </param>
            <returns> Resulting {@link Query} built for the term
            </returns>
            <exception cref="T:Lucene.Net.QueryParsers.ParseException">throw in overridden method to disallow
            </exception>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.GetPrefixQuery(System.String,System.String)">
            <summary> Factory method for generating a query (similar to
            {@link #getWildcardQuery}). Called when parser parses an input term
            token that uses prefix notation; that is, contains a single '*' wildcard
            character as its last character. Since this is a special case
            of generic wildcard term, and such a query can be optimized easily,
            this usually results in a different query object.
            <p/>
            Depending on settings, a prefix term may be lower-cased
            automatically. It will not go through the default Analyzer,
            however, since normal Analyzers are unlikely to work properly
            with wildcard templates.
            <p/>
            Can be overridden by extending classes, to provide custom handling for
            wild card queries, which may be necessary due to missing analyzer calls.
            
            </summary>
            <param name="field">Name of the field query will use.
            </param>
            <param name="termStr">Term token to use for building term for the query
            (<b>without</b> trailing '*' character!)
            
            </param>
            <returns> Resulting {@link Query} built for the term
            </returns>
            <exception cref="T:Lucene.Net.QueryParsers.ParseException">throw in overridden method to disallow
            </exception>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.GetFuzzyQuery(System.String,System.String,System.Single)">
            <summary> Factory method for generating a query (similar to
            {@link #getWildcardQuery}). Called when parser parses
            an input term token that has the fuzzy suffix (~) appended.
            
            </summary>
            <param name="field">Name of the field query will use.
            </param>
            <param name="termStr">Term token to use for building term for the query
            
            </param>
            <returns> Resulting {@link Query} built for the term
            </returns>
            <exception cref="T:Lucene.Net.QueryParsers.ParseException">throw in overridden method to disallow
            </exception>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.DiscardEscapeChar(System.String)">
            <summary> Returns a String where the escape char has been
            removed, or kept only once if there was a double escape.
            
            Supports escaped unicode characters, e. g. translates
            <code>\\u0041</code> to <code>A</code>.
            
            </summary>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.HexToInt(System.Char)">
            <summary>Returns the numeric value of the hexadecimal character </summary>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.Escape(System.String)">
            <summary> Returns a String where those characters that QueryParser
            expects to be escaped are escaped by a preceding <code>\</code>.
            </summary>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.Main(System.String[])">
            <summary> Command line tool to test QueryParser, using {@link Lucene.Net.Analysis.SimpleAnalyzer}.
            Usage:<br/>
            <code>java Lucene.Net.QueryParsers.QueryParser &lt;input&gt;</code>
            </summary>
        </member>
        <member name="F:Lucene.Net.QueryParsers.QueryParser.token_source">
            <summary>Generated Token Manager. </summary>
        </member>
        <member name="F:Lucene.Net.QueryParsers.QueryParser.token">
            <summary>Current token. </summary>
        </member>
        <member name="F:Lucene.Net.QueryParsers.QueryParser.jj_nt">
            <summary>Next token. </summary>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.#ctor(Lucene.Net.QueryParsers.CharStream)">
            <summary>Constructor with user supplied CharStream. </summary>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.ReInit(Lucene.Net.QueryParsers.CharStream)">
            <summary>Reinitialise. </summary>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.#ctor(Lucene.Net.QueryParsers.QueryParserTokenManager)">
            <summary>Constructor with generated Token Manager. </summary>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.ReInit(Lucene.Net.QueryParsers.QueryParserTokenManager)">
            <summary>Reinitialise. </summary>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.GetNextToken">
            <summary>Get the next Token. </summary>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.GetToken(System.Int32)">
            <summary>Get the specific Token. </summary>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.GenerateParseException">
            <summary>Generate ParseException. </summary>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.Enable_tracing">
            <summary>Enable tracing. </summary>
        </member>
        <member name="M:Lucene.Net.QueryParsers.QueryParser.Disable_tracing">
            <summary>Disable tracing. </summary>
        </member>
        <member name="T:Lucene.Net.QueryParsers.QueryParser.Operator">
            <summary>The default operator for parsing queries. 
            Use {@link QueryParser#setDefaultOperator} to change it.
            </summary>
        </member>
        <member name="T:Lucene.Net.Messages.NLSException">
            <summary> Interface that exceptions should implement to support lazy loading of messages.
            
            For Native Language Support (NLS), system of software internationalization.
            
            This Interface should be implemented by all exceptions that require
            translation
            
            </summary>
        </member>
        <member name="M:Lucene.Net.Messages.NLSException.GetMessageObject">
            <returns> a instance of a class that implements the Message interface
            </returns>
        </member>
        <member name="T:Lucene.Net.Index.TermVectorEntryFreqSortedComparator">
            <summary> Compares {@link Lucene.Net.Index.TermVectorEntry}s first by frequency and then by
            the term (case-sensitive)
            
            
            </summary>
        </member>
        <member name="T:Lucene.Net.Index.TermFreqVector">
            <summary>Provides access to stored term vector of 
            a document field.  The vector consists of the name of the field, an array of the terms tha occur in the field of the
            {@link Lucene.Net.Documents.Document} and a parallel array of frequencies.  Thus, getTermFrequencies()[5] corresponds with the
            frequency of getTerms()[5], assuming there are at least 5 terms in the Document.
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.TermFreqVector.GetField">
            <summary> The {@link Lucene.Net.Documents.Fieldable} name. </summary>
            <returns> The name of the field this vector is associated with.
            
            </returns>
        </member>
        <member name="M:Lucene.Net.Index.TermFreqVector.Size">
            <returns> The number of terms in the term vector.
            </returns>
        </member>
        <member name="M:Lucene.Net.Index.TermFreqVector.GetTerms">
            <returns> An Array of term texts in ascending order.
            </returns>
        </member>
        <member name="M:Lucene.Net.Index.TermFreqVector.GetTermFrequencies">
            <summary>Array of term frequencies. Locations of the array correspond one to one
            to the terms in the array obtained from <code>getTerms</code>
            method. Each location in the array contains the number of times this
            term occurs in the document or the document field.
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.TermFreqVector.IndexOf(System.String)">
            <summary>Return an index in the term numbers array returned from
            <code>getTerms</code> at which the term with the specified
            <code>term</code> appears. If this term does not appear in the array,
            return -1.
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.TermFreqVector.IndexesOf(System.String[],System.Int32,System.Int32)">
            <summary>Just like <code>indexOf(int)</code> but searches for a number of terms
            at the same time. Returns an array that has the same size as the number
            of terms searched for, each slot containing the result of searching for
            that term number.
            
            </summary>
            <param name="terms">array containing terms to look for
            </param>
            <param name="start">index in the array where the list of terms starts
            </param>
            <param name="len">the number of terms in the list
            </param>
        </member>
        <member name="T:Lucene.Net.Index.NormsWriterPerField">
            <summary>Taps into DocInverter, as an InvertedDocEndConsumer,
            which is called at the end of inverting each field.  We
            just look at the length for the field (docState.length)
            and record the norm. 
            </summary>
        </member>
        <member name="T:Lucene.Net.Index.IndexWriter">
            <summary>An <code>IndexWriter</code> creates and maintains an index.
            <p/>The <code>create</code> argument to the {@link
            #IndexWriter(Directory, Analyzer, boolean) constructor} determines 
            whether a new index is created, or whether an existing index is
            opened.  Note that you can open an index with <code>create=true</code>
            even while readers are using the index.  The old readers will 
            continue to search the "point in time" snapshot they had opened, 
            and won't see the newly created index until they re-open.  There are
            also {@link #IndexWriter(Directory, Analyzer) constructors}
            with no <code>create</code> argument which will create a new index
            if there is not already an index at the provided path and otherwise 
            open the existing index.<p/>
            <p/>In either case, documents are added with {@link #AddDocument(Document)
            addDocument} and removed with {@link #DeleteDocuments(Term)} or {@link
            #DeleteDocuments(Query)}. A document can be updated with {@link
            #UpdateDocument(Term, Document) updateDocument} (which just deletes
            and then adds the entire document). When finished adding, deleting 
            and updating documents, {@link #Close() close} should be called.<p/>
            <a name="flush"></a>
            <p/>These changes are buffered in memory and periodically
            flushed to the {@link Directory} (during the above method
            calls).  A flush is triggered when there are enough
            buffered deletes (see {@link #setMaxBufferedDeleteTerms})
            or enough added documents since the last flush, whichever
            is sooner.  For the added documents, flushing is triggered
            either by RAM usage of the documents (see {@link
            #setRAMBufferSizeMB}) or the number of added documents.
            The default is to flush when RAM usage hits 16 MB.  For
            best indexing speed you should flush by RAM usage with a
            large RAM buffer.  Note that flushing just moves the
            internal buffered state in IndexWriter into the index, but
            these changes are not visible to IndexReader until either
            {@link #Commit()} or {@link #close} is called.  A flush may
            also trigger one or more segment merges which by default
            run with a background thread so as not to block the
            addDocument calls (see <a href="#mergePolicy">below</a>
            for changing the {@link MergeScheduler}).<p/>
            <a name="autoCommit"></a>
            <p/>The optional <code>autoCommit</code> argument to the {@link
            #IndexWriter(Directory, boolean, Analyzer) constructors}
            controls visibility of the changes to {@link IndexReader}
            instances reading the same index.  When this is
            <code>false</code>, changes are not visible until {@link
            #Close()} or {@link #Commit()} is called.  Note that changes will still be
            flushed to the {@link Directory} as new files, but are 
            not committed (no new <code>segments_N</code> file is written 
            referencing the new files, nor are the files sync'd to stable storage)
            until {@link #Close()} or {@link #Commit()} is called.  If something
            goes terribly wrong (for example the JVM crashes), then
            the index will reflect none of the changes made since the
            last commit, or the starting state if commit was not called.
            You can also call {@link #Rollback()}, which closes the writer
            without committing any changes, and removes any index
            files that had been flushed but are now unreferenced.
            This mode is useful for preventing readers from refreshing
            at a bad time (for example after you've done all your
            deletes but before you've done your adds).  It can also be
            used to implement simple single-writer transactional
            semantics ("all or none").  You can do a two-phase commit
            by calling {@link #PrepareCommit()}
            followed by {@link #Commit()}. This is necessary when
            Lucene is working with an external resource (for example,
            a database) and both must either commit or rollback the
            transaction.<p/>
            <p/>When <code>autoCommit</code> is <code>true</code> then
            the writer will periodically commit on its own.  [<b>Deprecated</b>: Note that in 3.0, IndexWriter will
            no longer accept autoCommit=true (it will be hardwired to
            false).  You can always call {@link #Commit()} yourself
            when needed]. There is
            no guarantee when exactly an auto commit will occur (it
            used to be after every flush, but it is now after every
            completed merge, as of 2.4).  If you want to force a
            commit, call {@link #Commit()}, or, close the writer.  Once
            a commit has finished, newly opened {@link IndexReader} instances will
            see the changes to the index as of that commit.  When
            running in this mode, be careful not to refresh your
            readers while optimize or segment merges are taking place
            as this can tie up substantial disk space.<p/>
            </summary>
            <summary><p/>Regardless of <code>autoCommit</code>, an {@link
            IndexReader} or {@link Lucene.Net.Search.IndexSearcher} will only see the
            index as of the "point in time" that it was opened.  Any
            changes committed to the index after the reader was opened
            are not visible until the reader is re-opened.<p/>
            <p/>If an index will not have more documents added for a while and optimal search
            performance is desired, then either the full {@link #Optimize() optimize}
            method or partial {@link #Optimize(int)} method should be
            called before the index is closed.<p/>
            <p/>Opening an <code>IndexWriter</code> creates a lock file for the directory in use. Trying to open
            another <code>IndexWriter</code> on the same directory will lead to a
            {@link LockObtainFailedException}. The {@link LockObtainFailedException}
            is also thrown if an IndexReader on the same directory is used to delete documents
            from the index.<p/>
            </summary>
            <summary><a name="deletionPolicy"></a>
            <p/>Expert: <code>IndexWriter</code> allows an optional
            {@link IndexDeletionPolicy} implementation to be
            specified.  You can use this to control when prior commits
            are deleted from the index.  The default policy is {@link
            KeepOnlyLastCommitDeletionPolicy} which removes all prior
            commits as soon as a new commit is done (this matches
            behavior before 2.2).  Creating your own policy can allow
            you to explicitly keep previous "point in time" commits
            alive in the index for some time, to allow readers to
            refresh to the new commit without having the old commit
            deleted out from under them.  This is necessary on
            filesystems like NFS that do not support "delete on last
            close" semantics, which Lucene's "point in time" search
            normally relies on. <p/>
            <a name="mergePolicy"></a> <p/>Expert:
            <code>IndexWriter</code> allows you to separately change
            the {@link MergePolicy} and the {@link MergeScheduler}.
            The {@link MergePolicy} is invoked whenever there are
            changes to the segments in the index.  Its role is to
            select which merges to do, if any, and return a {@link
            MergePolicy.MergeSpecification} describing the merges.  It
            also selects merges to do for optimize().  (The default is
            {@link LogByteSizeMergePolicy}.  Then, the {@link
            MergeScheduler} is invoked with the requested merges and
            it decides when and how to run the merges.  The default is
            {@link ConcurrentMergeScheduler}. <p/>
            <a name="OOME"></a><p/><b>NOTE</b>: if you hit an
            OutOfMemoryError then IndexWriter will quietly record this
            fact and block all future segment commits.  This is a
            defensive measure in case any internal state (buffered
            documents and deletions) were corrupted.  Any subsequent
            calls to {@link #Commit()} will throw an
            IllegalStateException.  The only course of action is to
            call {@link #Close()}, which internally will call {@link
            #Rollback()}, to undo any changes to the index since the
            last commit.  If you opened the writer with autoCommit
            false you can also just call {@link #Rollback()}
            directly.<p/>
            <a name="thread-safety"></a><p/><b>NOTE</b>: {@link
            <code>IndexWriter</code>} instances are completely thread
            safe, meaning multiple threads can call any of its
            methods, concurrently.  If your application requires
            external synchronization, you should <b>not</b>
            synchronize on the <code>IndexWriter</code> instance as
            this may cause deadlock; use your own (non-Lucene) objects
            instead. <p/>
            </summary>
        </member>
        <member name="F:Lucene.Net.Index.IndexWriter.WRITE_LOCK_NAME">
            <summary> Name of the write lock in the index.</summary>
        </member>
        <member name="F:Lucene.Net.Index.IndexWriter.DISABLE_AUTO_FLUSH">
            <summary> Value to denote a flush trigger is disabled</summary>
        </member>
        <member name="F:Lucene.Net.Index.IndexWriter.DEFAULT_RAM_BUFFER_SIZE_MB">
            <summary> Default value is 16 MB (which means flush when buffered
            docs consume 16 MB RAM).  Change using {@link #setRAMBufferSizeMB}.
            </summary>
        </member>
        <member name="F:Lucene.Net.Index.IndexWriter.DEFAULT_MAX_FIELD_LENGTH">
            <summary> Default value is 10,000. Change using {@link #SetMaxFieldLength(int)}.</summary>
        </member>
        <member name="F:Lucene.Net.Index.IndexWriter.DEFAULT_TERM_INDEX_INTERVAL">
            <summary> Default value is 128. Change using {@link #SetTermIndexInterval(int)}.</summary>
        </member>
        <member name="F:Lucene.Net.Index.IndexWriter.WRITE_LOCK_TIMEOUT">
            <summary> Default value for the write lock timeout (1,000).</summary>
            <seealso cref="!:setDefaultWriteLockTimeout">
            </seealso>
        </member>
        <member name="F:Lucene.Net.Index.IndexWriter.DEFAULT_MERGE_FACTOR">
            <deprecated>
            </deprecated>
            <seealso cref="F:Lucene.Net.Index.LogMergePolicy.DEFAULT_MERGE_FACTOR">
            </seealso>
        </member>
        <member name="F:Lucene.Net.Index.IndexWriter.DEFAULT_MAX_BUFFERED_DOCS">
            <summary> Disabled by default (because IndexWriter flushes by RAM usage
            by default). Change using {@link #SetMaxBufferedDocs(int)}.
            </summary>
        </member>
        <member name="F:Lucene.Net.Index.IndexWriter.DEFAULT_MAX_BUFFERED_DELETE_TERMS">
            <summary> Disabled by default (because IndexWriter flushes by RAM usage
            by default). Change using {@link #SetMaxBufferedDeleteTerms(int)}.
            </summary>
        </member>
        <member name="F:Lucene.Net.Index.IndexWriter.DEFAULT_MAX_MERGE_DOCS">
            <deprecated>
            </deprecated>
            <seealso cref="!:LogDocMergePolicy.DEFAULT_MAX_MERGE_DOCS">
            </seealso>
        </member>
        <member name="F:Lucene.Net.Index.IndexWriter.MAX_TERM_LENGTH">
            <summary> Absolute hard maximum length for a term.  If a term
            arrives from the analyzer longer than this length, it
            is skipped and a message is printed to infoStream, if
            set (see {@link #setInfoStream}).
            </summary>
        </member>
        <member name="F:Lucene.Net.Index.IndexWriter.DEFAULT_MAX_SYNC_PAUSE_SECONDS">
            <summary> Default for {@link #getMaxSyncPauseSeconds}.  On
            Windows this defaults to 10.0 seconds; elsewhere it's
            0.
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.GetReader">
            <summary> Expert: returns a readonly reader, covering all committed as well as
            un-committed changes to the index. This provides "near real-time"
            searching, in that changes made during an IndexWriter session can be
            quickly made available for searching without closing the writer nor
            calling {@link #commit}.
            
            <p/>
            Note that this is functionally equivalent to calling {#commit} and then
            using {@link IndexReader#open} to open a new reader. But the turarnound
            time of this method should be faster since it avoids the potentially
            costly {@link #commit}.
            <p/>
            
            You must close the {@link IndexReader} returned by  this method once you are done using it.
            
            <p/>
            It's <i>near</i> real-time because there is no hard
            guarantee on how quickly you can get a new reader after
            making changes with IndexWriter.  You'll have to
            experiment in your situation to determine if it's
            faster enough.  As this is a new and experimental
            feature, please report back on your findings so we can
            learn, improve and iterate.<p/>
            
            <p/>The resulting reader suppports {@link
            IndexReader#reopen}, but that call will simply forward
            back to this method (though this may change in the
            future).<p/>
            
            <p/>The very first time this method is called, this
            writer instance will make every effort to pool the
            readers that it opens for doing merges, applying
            deletes, etc.  This means additional resources (RAM,
            file descriptors, CPU time) will be consumed.<p/>
            
            <p/>For lower latency on reopening a reader, you should call {@link #setMergedSegmentWarmer} 
            to call {@link #setMergedSegmentWarmer} to
            pre-warm a newly merged segment before it's committed
            to the index. This is important for minimizing index-to-search 
            delay after a large merge.
            
            <p/>If an addIndexes* call is running in another thread,
            then this reader will only search those segments from
            the foreign index that have been successfully copied
            over, so far<p/>.
            
            <p/><b>NOTE</b>: Once the writer is closed, any
            outstanding readers may continue to be used.  However,
            if you attempt to reopen any of those readers, you'll
            hit an {@link AlreadyClosedException}.<p/>
            
            <p/><b>NOTE:</b> This API is experimental and might
            change in incompatible ways in the next release.<p/>
            
            </summary>
            <returns> IndexReader that covers entire index plus all
            changes made so far by this IndexWriter instance
            
            </returns>
            <throws>  IOException </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.GetReader(System.Int32)">
            <summary>Expert: like {@link #getReader}, except you can
            specify which termInfosIndexDivisor should be used for
            any newly opened readers.
            </summary>
            <param name="termInfosIndexDivisor">Subsambles which indexed
            terms are loaded into RAM. This has the same effect as {@link
            IndexWriter#setTermIndexInterval} except that setting
            must be done at indexing time while this setting can be
            set per reader.  When set to N, then one in every
            N*termIndexInterval terms in the index is loaded into
            memory.  By setting this to a value > 1 you can reduce
            memory usage, at the expense of higher latency when
            loading a TermInfo.  The default value is 1.  Set this
            to -1 to skip loading the terms index entirely. 
            </param>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.NumDeletedDocs(Lucene.Net.Index.SegmentInfo)">
            <summary> Obtain the number of deleted docs for a pooled reader.
            If the reader isn't being pooled, the segmentInfo's 
            delCount is returned.
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.EnsureOpen(System.Boolean)">
            <summary> Used internally to throw an {@link
            AlreadyClosedException} if this IndexWriter has been
            closed.
            </summary>
            <throws>  AlreadyClosedException if this IndexWriter is </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.Message(System.String)">
            <summary> Prints a message to the infoStream (if non-null),
            prefixed with the identifying information for this
            writer and the thread that's calling it.
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.GetLogMergePolicy">
            <summary> Casts current mergePolicy to LogMergePolicy, and throws
            an exception if the mergePolicy is not a LogMergePolicy.
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.GetUseCompoundFile">
            <summary><p/>Get the current setting of whether newly flushed
            segments will use the compound file format.  Note that
            this just returns the value previously set with
            setUseCompoundFile(boolean), or the default value
            (true).  You cannot use this to query the status of
            previously flushed segments.<p/>
            
            <p/>Note that this method is a convenience method: it
            just calls mergePolicy.getUseCompoundFile as long as
            mergePolicy is an instance of {@link LogMergePolicy}.
            Otherwise an IllegalArgumentException is thrown.<p/>
            
            </summary>
            <seealso cref="!:SetUseCompoundFile(boolean)">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.SetUseCompoundFile(System.Boolean)">
            <summary><p/>Setting to turn on usage of a compound file. When on,
            multiple files for each segment are merged into a
            single file when a new segment is flushed.<p/>
            
            <p/>Note that this method is a convenience method: it
            just calls mergePolicy.setUseCompoundFile as long as
            mergePolicy is an instance of {@link LogMergePolicy}.
            Otherwise an IllegalArgumentException is thrown.<p/>
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.SetSimilarity(Lucene.Net.Search.Similarity)">
            <summary>Expert: Set the Similarity implementation used by this IndexWriter.
            
            </summary>
            <seealso cref="M:Lucene.Net.Search.Similarity.SetDefault(Lucene.Net.Search.Similarity)">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.GetSimilarity">
            <summary>Expert: Return the Similarity implementation used by this IndexWriter.
            
            <p/>This defaults to the current value of {@link Similarity#GetDefault()}.
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.SetTermIndexInterval(System.Int32)">
            <summary>Expert: Set the interval between indexed terms.  Large values cause less
            memory to be used by IndexReader, but slow random-access to terms.  Small
            values cause more memory to be used by an IndexReader, and speed
            random-access to terms.
            
            This parameter determines the amount of computation required per query
            term, regardless of the number of documents that contain that term.  In
            particular, it is the maximum number of other terms that must be
            scanned before a term is located and its frequency and position information
            may be processed.  In a large index with user-entered query terms, query
            processing time is likely to be dominated not by term lookup but rather
            by the processing of frequency and positional data.  In a small index
            or when many uncommon query terms are generated (e.g., by wildcard
            queries) term lookup may become a dominant cost.
            
            In particular, <code>numUniqueTerms/interval</code> terms are read into
            memory by an IndexReader, and, on average, <code>interval/2</code> terms
            must be scanned for each random term access.
            
            </summary>
            <seealso cref="F:Lucene.Net.Index.IndexWriter.DEFAULT_TERM_INDEX_INTERVAL">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.GetTermIndexInterval">
            <summary>Expert: Return the interval between indexed terms.
            
            </summary>
            <seealso cref="M:Lucene.Net.Index.IndexWriter.SetTermIndexInterval(System.Int32)">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.#ctor(System.String,Lucene.Net.Analysis.Analyzer,System.Boolean,Lucene.Net.Index.IndexWriter.MaxFieldLength)">
            <summary> Constructs an IndexWriter for the index in <code>path</code>.
            Text will be analyzed with <code>a</code>.  If <code>create</code>
            is true, then a new, empty index will be created in
            <code>path</code>, replacing the index already there,
            if any.
            
            <p/><b>NOTE</b>: autoCommit (see <a
            href="#autoCommit">above</a>) is set to false with this
            constructor.
            
            </summary>
            <param name="path">the path to the index directory
            </param>
            <param name="a">the analyzer to use
            </param>
            <param name="create"><code>true</code> to create the index or overwrite
            the existing one; <code>false</code> to append to the existing
            index
            </param>
            <param name="mfl">Maximum field length in number of tokens/terms: LIMITED, UNLIMITED, or user-specified
            via the MaxFieldLength constructor.
            </param>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  LockObtainFailedException if another writer </throws>
            <summary>  has this index open (<code>write.lock</code> could not
            be obtained)
            </summary>
            <throws>  IOException if the directory cannot be read/written to, or </throws>
            <summary>  if it does not exist and <code>create</code> is
            <code>false</code> or if there is any other low-level
            IO error
            </summary>
            <deprecated> Use {@link #IndexWriter(Directory, Analyzer,
            boolean, MaxFieldLength)}
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.#ctor(System.String,Lucene.Net.Analysis.Analyzer,System.Boolean)">
            <summary> Constructs an IndexWriter for the index in <code>path</code>.
            Text will be analyzed with <code>a</code>.  If <code>create</code>
            is true, then a new, empty index will be created in
            <code>path</code>, replacing the index already there, if any.
            
            </summary>
            <param name="path">the path to the index directory
            </param>
            <param name="a">the analyzer to use
            </param>
            <param name="create"><code>true</code> to create the index or overwrite
            the existing one; <code>false</code> to append to the existing
            index
            </param>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  LockObtainFailedException if another writer </throws>
            <summary>  has this index open (<code>write.lock</code> could not
            be obtained)
            </summary>
            <throws>  IOException if the directory cannot be read/written to, or </throws>
            <summary>  if it does not exist and <code>create</code> is
            <code>false</code> or if there is any other low-level
            IO error
            </summary>
            <deprecated> This constructor will be removed in the 3.0 release.
            Use {@link
            #IndexWriter(Directory,Analyzer,boolean,MaxFieldLength)}
            instead, and call {@link #Commit()} when needed.
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.#ctor(System.IO.FileInfo,Lucene.Net.Analysis.Analyzer,System.Boolean,Lucene.Net.Index.IndexWriter.MaxFieldLength)">
            <summary> Constructs an IndexWriter for the index in <code>path</code>.
            Text will be analyzed with <code>a</code>.  If <code>create</code>
            is true, then a new, empty index will be created in
            <code>path</code>, replacing the index already there, if any.
            
            <p/><b>NOTE</b>: autoCommit (see <a
            href="#autoCommit">above</a>) is set to false with this
            constructor.
            
            </summary>
            <param name="path">the path to the index directory
            </param>
            <param name="a">the analyzer to use
            </param>
            <param name="create"><code>true</code> to create the index or overwrite
            the existing one; <code>false</code> to append to the existing
            index
            </param>
            <param name="mfl">Maximum field length in number of terms/tokens: LIMITED, UNLIMITED, or user-specified
            via the MaxFieldLength constructor.
            </param>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  LockObtainFailedException if another writer </throws>
            <summary>  has this index open (<code>write.lock</code> could not
            be obtained)
            </summary>
            <throws>  IOException if the directory cannot be read/written to, or </throws>
            <summary>  if it does not exist and <code>create</code> is
            <code>false</code> or if there is any other low-level
            IO error
            </summary>
            <deprecated> Use {@link #IndexWriter(Directory,
            Analyzer, boolean, MaxFieldLength)}
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.#ctor(System.IO.FileInfo,Lucene.Net.Analysis.Analyzer,System.Boolean)">
            <summary> Constructs an IndexWriter for the index in <code>path</code>.
            Text will be analyzed with <code>a</code>.  If <code>create</code>
            is true, then a new, empty index will be created in
            <code>path</code>, replacing the index already there, if any.
            
            </summary>
            <param name="path">the path to the index directory
            </param>
            <param name="a">the analyzer to use
            </param>
            <param name="create"><code>true</code> to create the index or overwrite
            the existing one; <code>false</code> to append to the existing
            index
            </param>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  LockObtainFailedException if another writer </throws>
            <summary>  has this index open (<code>write.lock</code> could not
            be obtained)
            </summary>
            <throws>  IOException if the directory cannot be read/written to, or </throws>
            <summary>  if it does not exist and <code>create</code> is
            <code>false</code> or if there is any other low-level
            IO error
            </summary>
            <deprecated> This constructor will be removed in the 3.0 release.
            Use {@link
            #IndexWriter(Directory,Analyzer,boolean,MaxFieldLength)}
            instead, and call {@link #Commit()} when needed.
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.#ctor(Lucene.Net.Store.Directory,Lucene.Net.Analysis.Analyzer,System.Boolean,Lucene.Net.Index.IndexWriter.MaxFieldLength)">
            <summary> Constructs an IndexWriter for the index in <code>d</code>.
            Text will be analyzed with <code>a</code>.  If <code>create</code>
            is true, then a new, empty index will be created in
            <code>d</code>, replacing the index already there, if any.
            
            <p/><b>NOTE</b>: autoCommit (see <a
            href="#autoCommit">above</a>) is set to false with this
            constructor.
            
            </summary>
            <param name="d">the index directory
            </param>
            <param name="a">the analyzer to use
            </param>
            <param name="create"><code>true</code> to create the index or overwrite
            the existing one; <code>false</code> to append to the existing
            index
            </param>
            <param name="mfl">Maximum field length in number of terms/tokens: LIMITED, UNLIMITED, or user-specified
            via the MaxFieldLength constructor.
            </param>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  LockObtainFailedException if another writer </throws>
            <summary>  has this index open (<code>write.lock</code> could not
            be obtained)
            </summary>
            <throws>  IOException if the directory cannot be read/written to, or </throws>
            <summary>  if it does not exist and <code>create</code> is
            <code>false</code> or if there is any other low-level
            IO error
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.#ctor(Lucene.Net.Store.Directory,Lucene.Net.Analysis.Analyzer,System.Boolean)">
            <summary> Constructs an IndexWriter for the index in <code>d</code>.
            Text will be analyzed with <code>a</code>.  If <code>create</code>
            is true, then a new, empty index will be created in
            <code>d</code>, replacing the index already there, if any.
            
            </summary>
            <param name="d">the index directory
            </param>
            <param name="a">the analyzer to use
            </param>
            <param name="create"><code>true</code> to create the index or overwrite
            the existing one; <code>false</code> to append to the existing
            index
            </param>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  LockObtainFailedException if another writer </throws>
            <summary>  has this index open (<code>write.lock</code> could not
            be obtained)
            </summary>
            <throws>  IOException if the directory cannot be read/written to, or </throws>
            <summary>  if it does not exist and <code>create</code> is
            <code>false</code> or if there is any other low-level
            IO error
            </summary>
            <deprecated> This constructor will be removed in the 3.0
            release, and call {@link #Commit()} when needed.
            Use {@link #IndexWriter(Directory,Analyzer,boolean,MaxFieldLength)} instead.
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.#ctor(System.String,Lucene.Net.Analysis.Analyzer,Lucene.Net.Index.IndexWriter.MaxFieldLength)">
            <summary> Constructs an IndexWriter for the index in
            <code>path</code>, first creating it if it does not
            already exist.  Text will be analyzed with
            <code>a</code>.
            
            <p/><b>NOTE</b>: autoCommit (see <a
            href="#autoCommit">above</a>) is set to false with this
            constructor.
            
            </summary>
            <param name="path">the path to the index directory
            </param>
            <param name="a">the analyzer to use
            </param>
            <param name="mfl">Maximum field length in number of terms/tokens: LIMITED, UNLIMITED, or user-specified
            via the MaxFieldLength constructor.
            </param>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  LockObtainFailedException if another writer </throws>
            <summary>  has this index open (<code>write.lock</code> could not
            be obtained)
            </summary>
            <throws>  IOException if the directory cannot be </throws>
            <summary>  read/written to or if there is any other low-level
            IO error
            </summary>
            <deprecated> Use {@link #IndexWriter(Directory, Analyzer, MaxFieldLength)}
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.#ctor(System.String,Lucene.Net.Analysis.Analyzer)">
            <summary> Constructs an IndexWriter for the index in
            <code>path</code>, first creating it if it does not
            already exist.  Text will be analyzed with
            <code>a</code>.
            
            </summary>
            <param name="path">the path to the index directory
            </param>
            <param name="a">the analyzer to use
            </param>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  LockObtainFailedException if another writer </throws>
            <summary>  has this index open (<code>write.lock</code> could not
            be obtained)
            </summary>
            <throws>  IOException if the directory cannot be </throws>
            <summary>  read/written to or if there is any other low-level
            IO error
            </summary>
            <deprecated> This constructor will be removed in the 3.0
            release, and call {@link #Commit()} when needed.
            Use {@link #IndexWriter(Directory,Analyzer,MaxFieldLength)} instead.
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.#ctor(System.IO.FileInfo,Lucene.Net.Analysis.Analyzer,Lucene.Net.Index.IndexWriter.MaxFieldLength)">
            <summary> Constructs an IndexWriter for the index in
            <code>path</code>, first creating it if it does not
            already exist.  Text will be analyzed with
            <code>a</code>.
            
            <p/><b>NOTE</b>: autoCommit (see <a
            href="#autoCommit">above</a>) is set to false with this
            constructor.
            
            </summary>
            <param name="path">the path to the index directory
            </param>
            <param name="a">the analyzer to use
            </param>
            <param name="mfl">Maximum field length in number of terms/tokens: LIMITED, UNLIMITED, or user-specified
            via the MaxFieldLength constructor.
            </param>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  LockObtainFailedException if another writer </throws>
            <summary>  has this index open (<code>write.lock</code> could not
            be obtained)
            </summary>
            <throws>  IOException if the directory cannot be </throws>
            <summary>  read/written to or if there is any other low-level
            IO error
            </summary>
            <deprecated> Use {@link #IndexWriter(Directory,
            Analyzer, MaxFieldLength)}
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.#ctor(System.IO.FileInfo,Lucene.Net.Analysis.Analyzer)">
            <summary> Constructs an IndexWriter for the index in
            <code>path</code>, first creating it if it does not
            already exist.  Text will be analyzed with
            <code>a</code>.
            
            </summary>
            <param name="path">the path to the index directory
            </param>
            <param name="a">the analyzer to use
            </param>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  LockObtainFailedException if another writer </throws>
            <summary>  has this index open (<code>write.lock</code> could not
            be obtained)
            </summary>
            <throws>  IOException if the directory cannot be </throws>
            <summary>  read/written to or if there is any other low-level
            IO error
            </summary>
            <deprecated> This constructor will be removed in the 3.0 release.
            Use {@link #IndexWriter(Directory,Analyzer,MaxFieldLength)}
            instead, and call {@link #Commit()} when needed.
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.#ctor(Lucene.Net.Store.Directory,Lucene.Net.Analysis.Analyzer,Lucene.Net.Index.IndexWriter.MaxFieldLength)">
            <summary> Constructs an IndexWriter for the index in
            <code>d</code>, first creating it if it does not
            already exist.  Text will be analyzed with
            <code>a</code>.
            
            <p/><b>NOTE</b>: autoCommit (see <a
            href="#autoCommit">above</a>) is set to false with this
            constructor.
            
            </summary>
            <param name="d">the index directory
            </param>
            <param name="a">the analyzer to use
            </param>
            <param name="mfl">Maximum field length in number of terms/tokens: LIMITED, UNLIMITED, or user-specified
            via the MaxFieldLength constructor.
            </param>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  LockObtainFailedException if another writer </throws>
            <summary>  has this index open (<code>write.lock</code> could not
            be obtained)
            </summary>
            <throws>  IOException if the directory cannot be </throws>
            <summary>  read/written to or if there is any other low-level
            IO error
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.#ctor(Lucene.Net.Store.Directory,Lucene.Net.Analysis.Analyzer)">
            <summary> Constructs an IndexWriter for the index in
            <code>d</code>, first creating it if it does not
            already exist.  Text will be analyzed with
            <code>a</code>.
            
            </summary>
            <param name="d">the index directory
            </param>
            <param name="a">the analyzer to use
            </param>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  LockObtainFailedException if another writer </throws>
            <summary>  has this index open (<code>write.lock</code> could not
            be obtained)
            </summary>
            <throws>  IOException if the directory cannot be </throws>
            <summary>  read/written to or if there is any other low-level
            IO error
            </summary>
            <deprecated> This constructor will be removed in the 3.0 release.
            Use {@link
            #IndexWriter(Directory,Analyzer,MaxFieldLength)}
            instead, and call {@link #Commit()} when needed.
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.#ctor(Lucene.Net.Store.Directory,System.Boolean,Lucene.Net.Analysis.Analyzer)">
            <summary> Constructs an IndexWriter for the index in
            <code>d</code>, first creating it if it does not
            already exist.  Text will be analyzed with
            <code>a</code>.
            
            </summary>
            <param name="d">the index directory
            </param>
            <param name="autoCommit">see <a href="#autoCommit">above</a>
            </param>
            <param name="a">the analyzer to use
            </param>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  LockObtainFailedException if another writer </throws>
            <summary>  has this index open (<code>write.lock</code> could not
            be obtained)
            </summary>
            <throws>  IOException if the directory cannot be </throws>
            <summary>  read/written to or if there is any other low-level
            IO error
            </summary>
            <deprecated> This constructor will be removed in the 3.0 release.
            Use {@link
            #IndexWriter(Directory,Analyzer,MaxFieldLength)}
            instead, and call {@link #Commit()} when needed.
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.#ctor(Lucene.Net.Store.Directory,System.Boolean,Lucene.Net.Analysis.Analyzer,System.Boolean)">
            <summary> Constructs an IndexWriter for the index in <code>d</code>.
            Text will be analyzed with <code>a</code>.  If <code>create</code>
            is true, then a new, empty index will be created in
            <code>d</code>, replacing the index already there, if any.
            
            </summary>
            <param name="d">the index directory
            </param>
            <param name="autoCommit">see <a href="#autoCommit">above</a>
            </param>
            <param name="a">the analyzer to use
            </param>
            <param name="create"><code>true</code> to create the index or overwrite
            the existing one; <code>false</code> to append to the existing
            index
            </param>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  LockObtainFailedException if another writer </throws>
            <summary>  has this index open (<code>write.lock</code> could not
            be obtained)
            </summary>
            <throws>  IOException if the directory cannot be read/written to, or </throws>
            <summary>  if it does not exist and <code>create</code> is
            <code>false</code> or if there is any other low-level
            IO error
            </summary>
            <deprecated> This constructor will be removed in the 3.0 release.
            Use {@link
            #IndexWriter(Directory,Analyzer,boolean,MaxFieldLength)}
            instead, and call {@link #Commit()} when needed.
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.#ctor(Lucene.Net.Store.Directory,Lucene.Net.Analysis.Analyzer,Lucene.Net.Index.IndexDeletionPolicy,Lucene.Net.Index.IndexWriter.MaxFieldLength)">
            <summary> Expert: constructs an IndexWriter with a custom {@link
            IndexDeletionPolicy}, for the index in <code>d</code>,
            first creating it if it does not already exist.  Text
            will be analyzed with <code>a</code>.
            
            <p/><b>NOTE</b>: autoCommit (see <a
            href="#autoCommit">above</a>) is set to false with this
            constructor.
            
            </summary>
            <param name="d">the index directory
            </param>
            <param name="a">the analyzer to use
            </param>
            <param name="deletionPolicy">see <a href="#deletionPolicy">above</a>
            </param>
            <param name="mfl">whether or not to limit field lengths
            </param>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  LockObtainFailedException if another writer </throws>
            <summary>  has this index open (<code>write.lock</code> could not
            be obtained)
            </summary>
            <throws>  IOException if the directory cannot be </throws>
            <summary>  read/written to or if there is any other low-level
            IO error
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.#ctor(Lucene.Net.Store.Directory,System.Boolean,Lucene.Net.Analysis.Analyzer,Lucene.Net.Index.IndexDeletionPolicy)">
            <summary> Expert: constructs an IndexWriter with a custom {@link
            IndexDeletionPolicy}, for the index in <code>d</code>,
            first creating it if it does not already exist.  Text
            will be analyzed with <code>a</code>.
            
            </summary>
            <param name="d">the index directory
            </param>
            <param name="autoCommit">see <a href="#autoCommit">above</a>
            </param>
            <param name="a">the analyzer to use
            </param>
            <param name="deletionPolicy">see <a href="#deletionPolicy">above</a>
            </param>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  LockObtainFailedException if another writer </throws>
            <summary>  has this index open (<code>write.lock</code> could not
            be obtained)
            </summary>
            <throws>  IOException if the directory cannot be </throws>
            <summary>  read/written to or if there is any other low-level
            IO error
            </summary>
            <deprecated> This constructor will be removed in the 3.0 release.
            Use {@link
            #IndexWriter(Directory,Analyzer,IndexDeletionPolicy,MaxFieldLength)}
            instead, and call {@link #Commit()} when needed.
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.#ctor(Lucene.Net.Store.Directory,Lucene.Net.Analysis.Analyzer,System.Boolean,Lucene.Net.Index.IndexDeletionPolicy,Lucene.Net.Index.IndexWriter.MaxFieldLength)">
            <summary> Expert: constructs an IndexWriter with a custom {@link
            IndexDeletionPolicy}, for the index in <code>d</code>.
            Text will be analyzed with <code>a</code>.  If
            <code>create</code> is true, then a new, empty index
            will be created in <code>d</code>, replacing the index
            already there, if any.
            
            <p/><b>NOTE</b>: autoCommit (see <a
            href="#autoCommit">above</a>) is set to false with this
            constructor.
            
            </summary>
            <param name="d">the index directory
            </param>
            <param name="a">the analyzer to use
            </param>
            <param name="create"><code>true</code> to create the index or overwrite
            the existing one; <code>false</code> to append to the existing
            index
            </param>
            <param name="deletionPolicy">see <a href="#deletionPolicy">above</a>
            </param>
            <param name="mfl">{@link Lucene.Net.Index.IndexWriter.MaxFieldLength}, whether or not to limit field lengths.  Value is in number of terms/tokens
            </param>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  LockObtainFailedException if another writer </throws>
            <summary>  has this index open (<code>write.lock</code> could not
            be obtained)
            </summary>
            <throws>  IOException if the directory cannot be read/written to, or </throws>
            <summary>  if it does not exist and <code>create</code> is
            <code>false</code> or if there is any other low-level
            IO error
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.#ctor(Lucene.Net.Store.Directory,Lucene.Net.Analysis.Analyzer,System.Boolean,Lucene.Net.Index.IndexDeletionPolicy,Lucene.Net.Index.IndexWriter.MaxFieldLength,Lucene.Net.Index.DocumentsWriter.IndexingChain,Lucene.Net.Index.IndexCommit)">
            <summary> Expert: constructs an IndexWriter with a custom {@link
            IndexDeletionPolicy} and {@link IndexingChain}, 
            for the index in <code>d</code>.
            Text will be analyzed with <code>a</code>.  If
            <code>create</code> is true, then a new, empty index
            will be created in <code>d</code>, replacing the index
            already there, if any.
            
            <p/><b>NOTE</b>: autoCommit (see <a
            href="#autoCommit">above</a>) is set to false with this
            constructor.
            
            </summary>
            <param name="d">the index directory
            </param>
            <param name="a">the analyzer to use
            </param>
            <param name="create"><code>true</code> to create the index or overwrite
            the existing one; <code>false</code> to append to the existing
            index
            </param>
            <param name="deletionPolicy">see <a href="#deletionPolicy">above</a>
            </param>
            <param name="mfl">whether or not to limit field lengths, value is in number of terms/tokens.  See {@link Lucene.Net.Index.IndexWriter.MaxFieldLength}.
            </param>
            <param name="indexingChain">the {@link DocConsumer} chain to be used to 
            process documents
            </param>
            <param name="commit">which commit to open
            </param>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  LockObtainFailedException if another writer </throws>
            <summary>  has this index open (<code>write.lock</code> could not
            be obtained)
            </summary>
            <throws>  IOException if the directory cannot be read/written to, or </throws>
            <summary>  if it does not exist and <code>create</code> is
            <code>false</code> or if there is any other low-level
            IO error
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.#ctor(Lucene.Net.Store.Directory,System.Boolean,Lucene.Net.Analysis.Analyzer,System.Boolean,Lucene.Net.Index.IndexDeletionPolicy)">
            <summary> Expert: constructs an IndexWriter with a custom {@link
            IndexDeletionPolicy}, for the index in <code>d</code>.
            Text will be analyzed with <code>a</code>.  If
            <code>create</code> is true, then a new, empty index
            will be created in <code>d</code>, replacing the index
            already there, if any.
            
            </summary>
            <param name="d">the index directory
            </param>
            <param name="autoCommit">see <a href="#autoCommit">above</a>
            </param>
            <param name="a">the analyzer to use
            </param>
            <param name="create"><code>true</code> to create the index or overwrite
            the existing one; <code>false</code> to append to the existing
            index
            </param>
            <param name="deletionPolicy">see <a href="#deletionPolicy">above</a>
            </param>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  LockObtainFailedException if another writer </throws>
            <summary>  has this index open (<code>write.lock</code> could not
            be obtained)
            </summary>
            <throws>  IOException if the directory cannot be read/written to, or </throws>
            <summary>  if it does not exist and <code>create</code> is
            <code>false</code> or if there is any other low-level
            IO error
            </summary>
            <deprecated> This constructor will be removed in the 3.0 release.
            Use {@link
            #IndexWriter(Directory,Analyzer,boolean,IndexDeletionPolicy,MaxFieldLength)}
            instead, and call {@link #Commit()} when needed.
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.#ctor(Lucene.Net.Store.Directory,Lucene.Net.Analysis.Analyzer,Lucene.Net.Index.IndexDeletionPolicy,Lucene.Net.Index.IndexWriter.MaxFieldLength,Lucene.Net.Index.IndexCommit)">
            <summary> Expert: constructs an IndexWriter on specific commit
            point, with a custom {@link IndexDeletionPolicy}, for
            the index in <code>d</code>.  Text will be analyzed
            with <code>a</code>.
            
            <p/> This is only meaningful if you've used a {@link
            IndexDeletionPolicy} in that past that keeps more than
            just the last commit.
            
            <p/>This operation is similar to {@link #Rollback()},
            except that method can only rollback what's been done
            with the current instance of IndexWriter since its last
            commit, whereas this method can rollback to an
            arbitrary commit point from the past, assuming the
            {@link IndexDeletionPolicy} has preserved past
            commits.
            
            <p/><b>NOTE</b>: autoCommit (see <a
            href="#autoCommit">above</a>) is set to false with this
            constructor.
            
            </summary>
            <param name="d">the index directory
            </param>
            <param name="a">the analyzer to use
            </param>
            <param name="deletionPolicy">see <a href="#deletionPolicy">above</a>
            </param>
            <param name="mfl">whether or not to limit field lengths, value is in number of terms/tokens.  See {@link Lucene.Net.Index.IndexWriter.MaxFieldLength}.
            </param>
            <param name="commit">which commit to open
            </param>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  LockObtainFailedException if another writer </throws>
            <summary>  has this index open (<code>write.lock</code> could not
            be obtained)
            </summary>
            <throws>  IOException if the directory cannot be read/written to, or </throws>
            <summary>  if it does not exist and <code>create</code> is
            <code>false</code> or if there is any other low-level
            IO error
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.SetMergePolicy(Lucene.Net.Index.MergePolicy)">
            <summary> Expert: set the merge policy used by this writer.</summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.GetMergePolicy">
            <summary> Expert: returns the current MergePolicy in use by this writer.</summary>
            <seealso cref="!:setMergePolicy">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.SetMergeScheduler(Lucene.Net.Index.MergeScheduler)">
            <summary> Expert: set the merge scheduler used by this writer.</summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.GetMergeScheduler">
            <summary> Expert: returns the current MergePolicy in use by this
            writer.
            </summary>
            <seealso cref="!:setMergePolicy">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.SetMaxMergeDocs(System.Int32)">
            <summary><p/>Determines the largest segment (measured by
            document count) that may be merged with other segments.
            Small values (e.g., less than 10,000) are best for
            interactive indexing, as this limits the length of
            pauses while indexing to a few seconds.  Larger values
            are best for batched indexing and speedier
            searches.<p/>
            
            <p/>The default value is {@link Integer#MAX_VALUE}.<p/>
            
            <p/>Note that this method is a convenience method: it
            just calls mergePolicy.setMaxMergeDocs as long as
            mergePolicy is an instance of {@link LogMergePolicy}.
            Otherwise an IllegalArgumentException is thrown.<p/>
            
            <p/>The default merge policy ({@link
            LogByteSizeMergePolicy}) also allows you to set this
            limit by net size (in MB) of the segment, using {@link
            LogByteSizeMergePolicy#setMaxMergeMB}.<p/>
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.GetMaxMergeDocs">
            <summary> <p/>Returns the largest segment (measured by document
            count) that may be merged with other segments.<p/>
            
            <p/>Note that this method is a convenience method: it
            just calls mergePolicy.getMaxMergeDocs as long as
            mergePolicy is an instance of {@link LogMergePolicy}.
            Otherwise an IllegalArgumentException is thrown.<p/>
            
            </summary>
            <seealso cref="!:setMaxMergeDocs">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.SetMaxFieldLength(System.Int32)">
            <summary> The maximum number of terms that will be indexed for a single field in a
            document.  This limits the amount of memory required for indexing, so that
            collections with very large files will not crash the indexing process by
            running out of memory.  This setting refers to the number of running terms,
            not to the number of different terms.<p/>
            <strong>Note:</strong> this silently truncates large documents, excluding from the
            index all terms that occur further in the document.  If you know your source
            documents are large, be sure to set this value high enough to accomodate
            the expected size.  If you set it to Integer.MAX_VALUE, then the only limit
            is your memory, but you should anticipate an OutOfMemoryError.<p/>
            By default, no more than {@link #DEFAULT_MAX_FIELD_LENGTH} terms
            will be indexed for a field.
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.GetMaxFieldLength">
            <summary> Returns the maximum number of terms that will be
            indexed for a single field in a document.
            </summary>
            <seealso cref="!:setMaxFieldLength">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.SetReaderTermsIndexDivisor(System.Int32)">
            Sets the termsIndexDivisor passed to any readers that
            IndexWriter opens, for example when applying deletes
            or creating a near-real-time reader in {@link
            IndexWriter#getReader}.  Default value is {@link
            IndexReader#DEFAULT_TERMS_INDEX_DIVISOR}. 
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.GetReaderTermsIndexDivisor">
            @see #setReaderTermsIndexDivisor 
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.SetMaxBufferedDocs(System.Int32)">
            <summary>Determines the minimal number of documents required
            before the buffered in-memory documents are flushed as
            a new Segment.  Large values generally gives faster
            indexing.
            
            <p/>When this is set, the writer will flush every
            maxBufferedDocs added documents.  Pass in {@link
            #DISABLE_AUTO_FLUSH} to prevent triggering a flush due
            to number of buffered documents.  Note that if flushing
            by RAM usage is also enabled, then the flush will be
            triggered by whichever comes first.<p/>
            
            <p/>Disabled by default (writer flushes by RAM usage).<p/>
            
            </summary>
            <throws>  IllegalArgumentException if maxBufferedDocs is </throws>
            <summary> enabled but smaller than 2, or it disables maxBufferedDocs
            when ramBufferSize is already disabled
            </summary>
            <seealso cref="!:setRAMBufferSizeMB">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.PushMaxBufferedDocs">
            <summary> If we are flushing by doc count (not by RAM usage), and
            using LogDocMergePolicy then push maxBufferedDocs down
            as its minMergeDocs, to keep backwards compatibility.
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.GetMaxBufferedDocs">
            <summary> Returns the number of buffered added documents that will
            trigger a flush if enabled.
            </summary>
            <seealso cref="!:setMaxBufferedDocs">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.SetRAMBufferSizeMB(System.Double)">
            <summary>Determines the amount of RAM that may be used for
            buffering added documents and deletions before they are
            flushed to the Directory.  Generally for faster
            indexing performance it's best to flush by RAM usage
            instead of document count and use as large a RAM buffer
            as you can.
            
            <p/>When this is set, the writer will flush whenever
            buffered documents and deletions use this much RAM.
            Pass in {@link #DISABLE_AUTO_FLUSH} to prevent
            triggering a flush due to RAM usage.  Note that if
            flushing by document count is also enabled, then the
            flush will be triggered by whichever comes first.<p/>
            
            <p/> <b>NOTE</b>: the account of RAM usage for pending
            deletions is only approximate.  Specifically, if you
            delete by Query, Lucene currently has no way to measure
            the RAM usage if individual Queries so the accounting
            will under-estimate and you should compensate by either
            calling commit() periodically yourself, or by using
            {@link #setMaxBufferedDeleteTerms} to flush by count
            instead of RAM usage (each buffered delete Query counts
            as one).
            
            <p/>
            <b>NOTE</b>: because IndexWriter uses <code>int</code>s when managing its
            internal storage, the absolute maximum value for this setting is somewhat
            less than 2048 MB. The precise limit depends on various factors, such as
            how large your documents are, how many fields have norms, etc., so it's
            best to set this value comfortably under 2048.
            <p/>
            
            <p/> The default value is {@link #DEFAULT_RAM_BUFFER_SIZE_MB}.<p/>
            
            </summary>
            <throws>  IllegalArgumentException if ramBufferSize is </throws>
            <summary> enabled but non-positive, or it disables ramBufferSize
            when maxBufferedDocs is already disabled
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.GetRAMBufferSizeMB">
            <summary> Returns the value set by {@link #setRAMBufferSizeMB} if enabled.</summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.SetMaxBufferedDeleteTerms(System.Int32)">
            <summary> <p/>Determines the minimal number of delete terms required before the buffered
            in-memory delete terms are applied and flushed. If there are documents
            buffered in memory at the time, they are merged and a new segment is
            created.<p/>
            <p/>Disabled by default (writer flushes by RAM usage).<p/>
            
            </summary>
            <throws>  IllegalArgumentException if maxBufferedDeleteTerms </throws>
            <summary> is enabled but smaller than 1
            </summary>
            <seealso cref="!:setRAMBufferSizeMB">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.GetMaxBufferedDeleteTerms">
            <summary> Returns the number of buffered deleted terms that will
            trigger a flush if enabled.
            </summary>
            <seealso cref="!:setMaxBufferedDeleteTerms">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.SetMergeFactor(System.Int32)">
            <summary>Determines how often segment indices are merged by addDocument().  With
            smaller values, less RAM is used while indexing, and searches on
            unoptimized indices are faster, but indexing speed is slower.  With larger
            values, more RAM is used during indexing, and while searches on unoptimized
            indices are slower, indexing is faster.  Thus larger values (> 10) are best
            for batch index creation, and smaller values (&lt; 10) for indices that are
            interactively maintained.
            
            <p/>Note that this method is a convenience method: it
            just calls mergePolicy.setMergeFactor as long as
            mergePolicy is an instance of {@link LogMergePolicy}.
            Otherwise an IllegalArgumentException is thrown.<p/>
            
            <p/>This must never be less than 2.  The default value is 10.
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.GetMergeFactor">
            <summary> <p/>Returns the number of segments that are merged at
            once and also controls the total number of segments
            allowed to accumulate in the index.<p/>
            
            <p/>Note that this method is a convenience method: it
            just calls mergePolicy.getMergeFactor as long as
            mergePolicy is an instance of {@link LogMergePolicy}.
            Otherwise an IllegalArgumentException is thrown.<p/>
            
            </summary>
            <seealso cref="!:setMergeFactor">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.GetMaxSyncPauseSeconds">
            <summary> Expert: returns max delay inserted before syncing a
            commit point.  On Windows, at least, pausing before
            syncing can increase net indexing throughput.  The
            delay is variable based on size of the segment's files,
            and is only inserted when using
            ConcurrentMergeScheduler for merges.
            </summary>
            <deprecated> This will be removed in 3.0, when
            autoCommit=true is removed from IndexWriter.
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.SetMaxSyncPauseSeconds(System.Double)">
            <summary> Expert: sets the max delay before syncing a commit
            point.
            </summary>
            <seealso cref="!:getMaxSyncPauseSeconds">
            </seealso>
            <deprecated> This will be removed in 3.0, when
            autoCommit=true is removed from IndexWriter.
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.SetDefaultInfoStream(System.IO.StreamWriter)">
            <summary>If non-null, this will be the default infoStream used
            by a newly instantiated IndexWriter.
            </summary>
            <seealso cref="!:setInfoStream">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.GetDefaultInfoStream">
            <summary> Returns the current default infoStream for newly
            instantiated IndexWriters.
            </summary>
            <seealso cref="!:setDefaultInfoStream">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.SetInfoStream(System.IO.StreamWriter)">
            <summary>If non-null, information about merges, deletes and a
            message when maxFieldLength is reached will be printed
            to this.
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.GetInfoStream">
            <summary> Returns the current infoStream in use by this writer.</summary>
            <seealso cref="!:setInfoStream">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.Verbose">
            <summary>Returns true if verbosing is enabled (i.e., infoStream != null). </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.SetWriteLockTimeout(System.Int64)">
            <seealso cref="!:setDefaultWriteLockTimeout"> to change the default value for all instances of IndexWriter.
            </seealso>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.GetWriteLockTimeout">
            <summary> Returns allowed timeout when acquiring the write lock.</summary>
            <seealso cref="!:setWriteLockTimeout">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.SetDefaultWriteLockTimeout(System.Int64)">
            <summary> Sets the default (for any instance of IndexWriter) maximum time to wait for a write lock (in
            milliseconds).
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.GetDefaultWriteLockTimeout">
            <summary> Returns default write lock timeout for newly
            instantiated IndexWriters.
            </summary>
            <seealso cref="!:setDefaultWriteLockTimeout">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.Close">
            <summary> Commits all changes to an index and closes all
            associated files.  Note that this may be a costly
            operation, so, try to re-use a single writer instead of
            closing and opening a new one.  See {@link #Commit()} for
            caveats about write caching done by some IO devices.
            
            <p/> If an Exception is hit during close, eg due to disk
            full or some other reason, then both the on-disk index
            and the internal state of the IndexWriter instance will
            be consistent.  However, the close will not be complete
            even though part of it (flushing buffered documents)
            may have succeeded, so the write lock will still be
            held.<p/>
            
            <p/> If you can correct the underlying cause (eg free up
            some disk space) then you can call close() again.
            Failing that, if you want to force the write lock to be
            released (dangerous, because you may then lose buffered
            docs in the IndexWriter instance) then you can do
            something like this:<p/>
            
            <pre>
            try {
            writer.close();
            } finally {
            if (IndexWriter.isLocked(directory)) {
            IndexWriter.unlock(directory);
            }
            }
            </pre>
            
            after which, you must be certain not to use the writer
            instance anymore.<p/>
            
            <p/><b>NOTE</b>: if this method hits an OutOfMemoryError
            you should immediately close the writer, again.  See <a
            href="#OOME">above</a> for details.<p/>
            
            </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.IndexWriter.Dispose">
            <summary>
            .NET
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.Close(System.Boolean)">
            <summary> Closes the index with or without waiting for currently
            running merges to finish.  This is only meaningful when
            using a MergeScheduler that runs merges in background
            threads.
            
            <p/><b>NOTE</b>: if this method hits an OutOfMemoryError
            you should immediately close the writer, again.  See <a
            href="#OOME">above</a> for details.<p/>
            
            <p/><b>NOTE</b>: it is dangerous to always call
            close(false), especially when IndexWriter is not open
            for very long, because this can result in "merge
            starvation" whereby long merges will never have a
            chance to finish.  This will cause too many segments in
            your index over time.<p/>
            
            </summary>
            <param name="waitForMerges">if true, this call will block
            until all merges complete; else, it will ask all
            running merges to abort, wait until those merges have
            finished (which should be at most a few seconds), and
            then return.
            </param>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.FlushDocStores">
            <summary>Tells the docWriter to close its currently open shared
            doc stores (stored fields &amp; vectors files).
            Return value specifices whether new doc store files are compound or not.
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.GetDirectory">
            <summary>Returns the Directory used by this index. </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.GetAnalyzer">
            <summary>Returns the analyzer used by this index. </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.DocCount">
            <summary>Returns the number of documents currently in this
            index, not counting deletions.
            </summary>
            <deprecated> Please use {@link #MaxDoc()} (same as this
            method) or {@link #NumDocs()} (also takes deletions
            into account), instead. 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.MaxDoc">
            <summary>Returns total number of docs in this index, including
            docs not yet flushed (still in the RAM buffer),
            not counting deletions.
            </summary>
            <seealso cref="!:numDocs">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.NumDocs">
            <summary>Returns total number of docs in this index, including
            docs not yet flushed (still in the RAM buffer), and
            including deletions.  <b>NOTE:</b> buffered deletions
            are not counted.  If you really need these to be
            counted you should call {@link #Commit()} first.
            </summary>
            <seealso cref="!:numDocs">
            </seealso>
        </member>
        <member name="F:Lucene.Net.Index.IndexWriter.maxFieldLength">
            <summary> The maximum number of terms that will be indexed for a single field in a
            document.  This limits the amount of memory required for indexing, so that
            collections with very large files will not crash the indexing process by
            running out of memory.<p/>
            Note that this effectively truncates large documents, excluding from the
            index terms that occur further in the document.  If you know your source
            documents are large, be sure to set this value high enough to accomodate
            the expected size.  If you set it to Integer.MAX_VALUE, then the only limit
            is your memory, but you should anticipate an OutOfMemoryError.<p/>
            By default, no more than 10,000 terms will be indexed for a field.
            
            </summary>
            <seealso cref="T:Lucene.Net.Index.IndexWriter.MaxFieldLength">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.AddDocument(Lucene.Net.Documents.Document)">
            <summary> Adds a document to this index.  If the document contains more than
            {@link #SetMaxFieldLength(int)} terms for a given field, the remainder are
            discarded.
            
            <p/> Note that if an Exception is hit (for example disk full)
            then the index will be consistent, but this document
            may not have been added.  Furthermore, it's possible
            the index will have one segment in non-compound format
            even when using compound files (when a merge has
            partially succeeded).<p/>
            
            <p/> This method periodically flushes pending documents
            to the Directory (see <a href="#flush">above</a>), and
            also periodically triggers segment merges in the index
            according to the {@link MergePolicy} in use.<p/>
            
            <p/>Merges temporarily consume space in the
            directory. The amount of space required is up to 1X the
            size of all segments being merged, when no
            readers/searchers are open against the index, and up to
            2X the size of all segments being merged when
            readers/searchers are open against the index (see
            {@link #Optimize()} for details). The sequence of
            primitive merge operations performed is governed by the
            merge policy.
            
            <p/>Note that each term in the document can be no longer
            than 16383 characters, otherwise an
            IllegalArgumentException will be thrown.<p/>
            
            <p/>Note that it's possible to create an invalid Unicode
            string in java if a UTF16 surrogate pair is malformed.
            In this case, the invalid characters are silently
            replaced with the Unicode replacement character
            U+FFFD.<p/>
            
            <p/><b>NOTE</b>: if this method hits an OutOfMemoryError
            you should immediately close the writer.  See <a
            href="#OOME">above</a> for details.<p/>
            
            </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.IndexWriter.AddDocument(Lucene.Net.Documents.Document,Lucene.Net.Analysis.Analyzer)">
            <summary> Adds a document to this index, using the provided analyzer instead of the
            value of {@link #GetAnalyzer()}.  If the document contains more than
            {@link #SetMaxFieldLength(int)} terms for a given field, the remainder are
            discarded.
            
            <p/>See {@link #AddDocument(Document)} for details on
            index and IndexWriter state after an Exception, and
            flushing/merging temporary free space requirements.<p/>
            
            <p/><b>NOTE</b>: if this method hits an OutOfMemoryError
            you should immediately close the writer.  See <a
            href="#OOME">above</a> for details.<p/>
            
            </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.IndexWriter.DeleteDocuments(Lucene.Net.Index.Term)">
            <summary> Deletes the document(s) containing <code>term</code>.
            
            <p/><b>NOTE</b>: if this method hits an OutOfMemoryError
            you should immediately close the writer.  See <a
            href="#OOME">above</a> for details.<p/>
            
            </summary>
            <param name="term">the term to identify the documents to be deleted
            </param>
            <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.IndexWriter.DeleteDocuments(Lucene.Net.Index.Term[])">
            <summary> Deletes the document(s) containing any of the
            terms. All deletes are flushed at the same time.
            
            <p/><b>NOTE</b>: if this method hits an OutOfMemoryError
            you should immediately close the writer.  See <a
            href="#OOME">above</a> for details.<p/>
            
            </summary>
            <param name="terms">array of terms to identify the documents
            to be deleted
            </param>
            <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.IndexWriter.DeleteDocuments(Lucene.Net.Search.Query)">
            <summary> Deletes the document(s) matching the provided query.
            
            <p/><b>NOTE</b>: if this method hits an OutOfMemoryError
            you should immediately close the writer.  See <a
            href="#OOME">above</a> for details.<p/>
            
            </summary>
            <param name="query">the query to identify the documents to be deleted
            </param>
            <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.IndexWriter.DeleteDocuments(Lucene.Net.Search.Query[])">
            <summary> Deletes the document(s) matching any of the provided queries.
            All deletes are flushed at the same time.
            
            <p/><b>NOTE</b>: if this method hits an OutOfMemoryError
            you should immediately close the writer.  See <a
            href="#OOME">above</a> for details.<p/>
            
            </summary>
            <param name="queries">array of queries to identify the documents
            to be deleted
            </param>
            <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.IndexWriter.UpdateDocument(Lucene.Net.Index.Term,Lucene.Net.Documents.Document)">
            <summary> Updates a document by first deleting the document(s)
            containing <code>term</code> and then adding the new
            document.  The delete and then add are atomic as seen
            by a reader on the same index (flush may happen only after
            the add).
            
            <p/><b>NOTE</b>: if this method hits an OutOfMemoryError
            you should immediately close the writer.  See <a
            href="#OOME">above</a> for details.<p/>
            
            </summary>
            <param name="term">the term to identify the document(s) to be
            deleted
            </param>
            <param name="doc">the document to be added
            </param>
            <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.IndexWriter.UpdateDocument(Lucene.Net.Index.Term,Lucene.Net.Documents.Document,Lucene.Net.Analysis.Analyzer)">
            <summary> Updates a document by first deleting the document(s)
            containing <code>term</code> and then adding the new
            document.  The delete and then add are atomic as seen
            by a reader on the same index (flush may happen only after
            the add).
            
            <p/><b>NOTE</b>: if this method hits an OutOfMemoryError
            you should immediately close the writer.  See <a
            href="#OOME">above</a> for details.<p/>
            
            </summary>
            <param name="term">the term to identify the document(s) to be
            deleted
            </param>
            <param name="doc">the document to be added
            </param>
            <param name="analyzer">the analyzer to use when analyzing the document
            </param>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  IOException if there is a low-level IO error </throws>
        </member>
        <member name="F:Lucene.Net.Index.IndexWriter.infoStream">
            <summary>If non-null, information about merges will be printed to this.</summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.Optimize">
            <summary> Requests an "optimize" operation on an index, priming the index
            for the fastest available search. Traditionally this has meant
            merging all segments into a single segment as is done in the
            default merge policy, but individaul merge policies may implement
            optimize in different ways.
            
            <p/>It is recommended that this method be called upon completion of indexing.  In
            environments with frequent updates, optimize is best done during low volume times, if at all. 
            
            <p/>
            <p/>See http://www.gossamer-threads.com/lists/lucene/java-dev/47895 for more discussion. <p/>
            
            <p/>Note that optimize requires 2X the index size free
            space in your Directory (3X if you're using compound
            file format).  For example, if your index
            size is 10 MB then you need 20 MB free for optimize to
            complete (30 MB if you're using compound fiel format).<p/>
            
            <p/>If some but not all readers re-open while an
            optimize is underway, this will cause &gt; 2X temporary
            space to be consumed as those new readers will then
            hold open the partially optimized segments at that
            time.  It is best not to re-open readers while optimize
            is running.<p/>
            
            <p/>The actual temporary usage could be much less than
            these figures (it depends on many factors).<p/>
            
            <p/>In general, once the optimize completes, the total size of the
            index will be less than the size of the starting index.
            It could be quite a bit smaller (if there were many
            pending deletes) or just slightly smaller.<p/>
            
            <p/>If an Exception is hit during optimize(), for example
            due to disk full, the index will not be corrupt and no
            documents will have been lost.  However, it may have
            been partially optimized (some segments were merged but
            not all), and it's possible that one of the segments in
            the index will be in non-compound format even when
            using compound file format.  This will occur when the
            Exception is hit during conversion of the segment into
            compound format.<p/>
            
            <p/>This call will optimize those segments present in
            the index when the call started.  If other threads are
            still adding documents and flushing segments, those
            newly created segments will not be optimized unless you
            call optimize again.<p/>
            
            <p/><b>NOTE</b>: if this method hits an OutOfMemoryError
            you should immediately close the writer.  See <a href="#OOME">above</a> for details.<p/>
            
            </summary>
            <throws>  CorruptIndexException if the index is corrupt </throws>
            <throws>  IOException if there is a low-level IO error </throws>
            <seealso cref="!:LogMergePolicy.findMergesForOptimize">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.Optimize(System.Int32)">
            <summary> Optimize the index down to &lt;= maxNumSegments.  If
            maxNumSegments==1 then this is the same as {@link
            #Optimize()}.
            
            <p/><b>NOTE</b>: if this method hits an OutOfMemoryError
            you should immediately close the writer.  See <a
            href="#OOME">above</a> for details.<p/>
            
            </summary>
            <param name="maxNumSegments">maximum number of segments left
            in the index after optimization finishes
            </param>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.Optimize(System.Boolean)">
            <summary>Just like {@link #Optimize()}, except you can specify
            whether the call should block until the optimize
            completes.  This is only meaningful with a
            {@link MergeScheduler} that is able to run merges in
            background threads.
            
            <p/><b>NOTE</b>: if this method hits an OutOfMemoryError
            you should immediately close the writer.  See <a
            href="#OOME">above</a> for details.<p/>
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.Optimize(System.Int32,System.Boolean)">
            <summary>Just like {@link #Optimize(int)}, except you can
            specify whether the call should block until the
            optimize completes.  This is only meaningful with a
            {@link MergeScheduler} that is able to run merges in
            background threads.
            
            <p/><b>NOTE</b>: if this method hits an OutOfMemoryError
            you should immediately close the writer.  See <a
            href="#OOME">above</a> for details.<p/>
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.OptimizeMergesPending">
            <summary>Returns true if any merges in pendingMerges or
            runningMerges are optimization merges. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.ExpungeDeletes(System.Boolean)">
            <summary>Just like {@link #ExpungeDeletes()}, except you can
            specify whether the call should block until the
            operation completes.  This is only meaningful with a
            {@link MergeScheduler} that is able to run merges in
            background threads.
            
            <p/><b>NOTE</b>: if this method hits an OutOfMemoryError
            you should immediately close the writer.  See <a
            href="#OOME">above</a> for details.<p/>
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.ExpungeDeletes">
            <summary>Expunges all deletes from the index.  When an index
            has many document deletions (or updates to existing
            documents), it's best to either call optimize or
            expungeDeletes to remove all unused data in the index
            associated with the deleted documents.  To see how
            many deletions you have pending in your index, call
            {@link IndexReader#numDeletedDocs}
            This saves disk space and memory usage while
            searching.  expungeDeletes should be somewhat faster
            than optimize since it does not insist on reducing the
            index to a single segment (though, this depends on the
            {@link MergePolicy}; see {@link
            MergePolicy#findMergesToExpungeDeletes}.). Note that
            this call does not first commit any buffered
            documents, so you must do so yourself if necessary.
            See also {@link #ExpungeDeletes(boolean)}
            
            <p/><b>NOTE</b>: if this method hits an OutOfMemoryError
            you should immediately close the writer.  See <a
            href="#OOME">above</a> for details.<p/>
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.MaybeMerge">
            <summary> Expert: asks the mergePolicy whether any merges are
            necessary now and if so, runs the requested merges and
            then iterate (test again if merges are needed) until no
            more merges are returned by the mergePolicy.
            
            Explicit calls to maybeMerge() are usually not
            necessary. The most common case is when merge policy
            parameters have changed.
            
            <p/><b>NOTE</b>: if this method hits an OutOfMemoryError
            you should immediately close the writer.  See <a
            href="#OOME">above</a> for details.<p/>
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.GetNextMerge">
            <summary>Expert: the {@link MergeScheduler} calls this method
            to retrieve the next merge requested by the
            MergePolicy 
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.GetNextExternalMerge">
            <summary>Like getNextMerge() except only returns a merge if it's
            external. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.Abort">
            <deprecated> Please use {@link #rollback} instead.
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.Rollback">
            <summary> Close the <code>IndexWriter</code> without committing
            any changes that have occurred since the last commit
            (or since it was opened, if commit hasn't been called).
            This removes any temporary files that had been created,
            after which the state of the index will be the same as
            it was when commit() was last called or when this
            writer was first opened.  This can only be called when
            this IndexWriter was opened with
            <code>autoCommit=false</code>.  This also clears a
            previous call to {@link #prepareCommit}.
            </summary>
            <throws>  IllegalStateException if this is called when </throws>
            <summary>  the writer was opened with <code>autoCommit=true</code>.
            </summary>
            <throws>  IOException if there is a low-level IO error </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.DeleteAll">
            <summary> Delete all documents in the index.
            
            <p/>This method will drop all buffered documents and will 
            remove all segments from the index. This change will not be
            visible until a {@link #Commit()} has been called. This method
            can be rolled back using {@link #Rollback()}.<p/>
            
            <p/>NOTE: this method is much faster than using deleteDocuments( new MatchAllDocsQuery() ).<p/>
            
            <p/>NOTE: this method will forcefully abort all merges
            in progress.  If other threads are running {@link
            #Optimize()} or any of the addIndexes methods, they
            will receive {@link MergePolicy.MergeAbortedException}s.
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.WaitForMerges">
            <summary> Wait for any currently outstanding merges to finish.
            
            <p/>It is guaranteed that any merges started prior to calling this method 
            will have completed once this method completes.<p/>
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.AddIndexes(Lucene.Net.Store.Directory[])">
            <summary>Merges all segments from an array of indexes into this index.
            
            <p/><b>NOTE</b>: if this method hits an OutOfMemoryError
            you should immediately close the writer.  See <a
            href="#OOME">above</a> for details.<p/>
            
            </summary>
            <deprecated> Use {@link #addIndexesNoOptimize} instead,
            then separately call {@link #optimize} afterwards if
            you need to.
            
            </deprecated>
            <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.IndexWriter.AddIndexesNoOptimize(Lucene.Net.Store.Directory[])">
            <summary> Merges all segments from an array of indexes into this
            index.
            
            <p/>This may be used to parallelize batch indexing.  A large document
            collection can be broken into sub-collections.  Each sub-collection can be
            indexed in parallel, on a different thread, process or machine.  The
            complete index can then be created by merging sub-collection indexes
            with this method.
            
            <p/><b>NOTE:</b> the index in each Directory must not be
            changed (opened by a writer) while this method is
            running.  This method does not acquire a write lock in
            each input Directory, so it is up to the caller to
            enforce this.
            
            <p/><b>NOTE:</b> while this is running, any attempts to
            add or delete documents (with another thread) will be
            paused until this method completes.
            
            <p/>This method is transactional in how Exceptions are
            handled: it does not commit a new segments_N file until
            all indexes are added.  This means if an Exception
            occurs (for example disk full), then either no indexes
            will have been added or they all will have been.<p/>
            
            <p/>Note that this requires temporary free space in the
            Directory up to 2X the sum of all input indexes
            (including the starting index).  If readers/searchers
            are open against the starting index, then temporary
            free space required will be higher by the size of the
            starting index (see {@link #Optimize()} for details).
            <p/>
            
            <p/>Once this completes, the final size of the index
            will be less than the sum of all input index sizes
            (including the starting index).  It could be quite a
            bit smaller (if there were many pending deletes) or
            just slightly smaller.<p/>
            
            <p/>
            This requires this index not be among those to be added.
            
            <p/><b>NOTE</b>: if this method hits an OutOfMemoryError
            you should immediately close the writer.  See <a
            href="#OOME">above</a> for details.<p/>
            
            </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.IndexWriter.AddIndexes(Lucene.Net.Index.IndexReader[])">
            <summary>Merges the provided indexes into this index.
            <p/>After this completes, the index is optimized. <p/>
            <p/>The provided IndexReaders are not closed.<p/>
            
            <p/><b>NOTE:</b> while this is running, any attempts to
            add or delete documents (with another thread) will be
            paused until this method completes.
            
            <p/>See {@link #AddIndexesNoOptimize(Directory[])} for
            details on transactional semantics, temporary free
            space required in the Directory, and non-CFS segments
            on an Exception.<p/>
            
            <p/><b>NOTE</b>: if this method hits an OutOfMemoryError
            you should immediately close the writer.  See <a
            href="#OOME">above</a> for details.<p/>
            
            </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.IndexWriter.DoAfterFlush">
            <summary>
             A hook for extending classes to execute operations after pending added and
             deleted documents have been flushed to the Directory but before the change
             is committed (new segments_N file written).
            </summary>   
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.Flush">
            <summary> Flush all in-memory buffered updates (adds and deletes)
            to the Directory. 
            <p/>Note: while this will force buffered docs to be
            pushed into the index, it will not make these docs
            visible to a reader.  Use {@link #Commit()} instead
            
            <p/><b>NOTE</b>: if this method hits an OutOfMemoryError
            you should immediately close the writer.  See <a
            href="#OOME">above</a> for details.<p/>
            
            </summary>
            <deprecated> please call {@link #Commit()}) instead
            
            </deprecated>
            <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.IndexWriter.DoBeforeFlush">
            <summary>
             A hook for extending classes to execute operations before pending added and
             deleted documents are flushed to the Directory.
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.PrepareCommit">
            <summary>Expert: prepare for commit.
            
            <p/><b>NOTE</b>: if this method hits an OutOfMemoryError
            you should immediately close the writer.  See <a href="#OOME">above</a> for details.<p/>
            
            </summary>
            <seealso cref="!:PrepareCommit(Map)">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.PrepareCommit(System.Collections.Generic.IDictionary{System.String,System.String})">
            <summary><p/>Expert: prepare for commit, specifying
            commitUserData Map (String -> String).  This does the
            first phase of 2-phase commit.  You can only call this
            when autoCommit is false.  This method does all steps
            necessary to commit changes since this writer was
            opened: flushes pending added and deleted docs, syncs
            the index files, writes most of next segments_N file.
            After calling this you must call either {@link
            #Commit()} to finish the commit, or {@link
            #Rollback()} to revert the commit and undo all changes
            done since the writer was opened.<p/>
            
            You can also just call {@link #Commit(Map)} directly
            without prepareCommit first in which case that method
            will internally call prepareCommit.
            
            <p/><b>NOTE</b>: if this method hits an OutOfMemoryError
            you should immediately close the writer.  See <a
            href="#OOME">above</a> for details.<p/>
            
            </summary>
            <param name="commitUserData">Opaque Map (String->String)
            that's recorded into the segments file in the index,
            and retrievable by {@link
            IndexReader#getCommitUserData}.  Note that when
            IndexWriter commits itself, for example if open with
            autoCommit=true, or, during {@link #close}, the
            commitUserData is unchanged (just carried over from
            the prior commit).  If this is null then the previous
            commitUserData is kept.  Also, the commitUserData will
            only "stick" if there are actually changes in the
            index to commit.  Therefore it's best to use this
            feature only when autoCommit is false.
            </param>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.Commit">
            <summary> <p/>Commits all pending changes (added &amp; deleted
            documents, optimizations, segment merges, added
            indexes, etc.) to the index, and syncs all referenced
            index files, such that a reader will see the changes
            and the index updates will survive an OS or machine
            crash or power loss.  Note that this does not wait for
            any running background merges to finish.  This may be a
            costly operation, so you should test the cost in your
            application and do it only when really necessary.<p/>
            
            <p/> Note that this operation calls Directory.sync on
            the index files.  That call should not return until the
            file contents &amp; metadata are on stable storage.  For
            FSDirectory, this calls the OS's fsync.  But, beware:
            some hardware devices may in fact cache writes even
            during fsync, and return before the bits are actually
            on stable storage, to give the appearance of faster
            performance.  If you have such a device, and it does
            not have a battery backup (for example) then on power
            loss it may still lose data.  Lucene cannot guarantee
            consistency on such devices.  <p/>
            
            <p/><b>NOTE</b>: if this method hits an OutOfMemoryError
            you should immediately close the writer.  See <a href="#OOME">above</a> for details.<p/>
            
            </summary>
            <seealso cref="!:prepareCommit">
            </seealso>
            <seealso cref="!:Commit(Map)">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.Commit(System.Collections.Generic.IDictionary{System.String,System.String})">
            <summary>Commits all changes to the index, specifying a
            commitUserData Map (String -> String).  This just
            calls {@link #PrepareCommit(Map)} (if you didn't
            already call it) and then {@link #finishCommit}.
            
            <p/><b>NOTE</b>: if this method hits an OutOfMemoryError
            you should immediately close the writer.  See <a
            href="#OOME">above</a> for details.<p/>
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.Flush(System.Boolean,System.Boolean,System.Boolean)">
            <summary> Flush all in-memory buffered udpates (adds and deletes)
            to the Directory.
            </summary>
            <param name="triggerMerge">if true, we may merge segments (if
            deletes or docs were flushed) if necessary
            </param>
            <param name="flushDocStores">if false we are allowed to keep
            doc stores open to share with the next segment
            </param>
            <param name="flushDeletes">whether pending deletes should also
            be flushed
            </param>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.RamSizeInBytes">
            <summary>Expert:  Return the total size of all index files currently cached in memory.
            Useful for size management with flushRamDocs()
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.NumRamDocs">
            <summary>Expert:  Return the number of documents currently
            buffered in RAM. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.CommitMergedDeletes(Lucene.Net.Index.MergePolicy.OneMerge,Lucene.Net.Index.SegmentReader)">
            <summary>Carefully merges deletes for the segments we just
            merged.  This is tricky because, although merging will
            clear all deletes (compacts the documents), new
            deletes may have been flushed to the segments since
            the merge was started.  This method "carries over"
            such new deletes onto the newly merged segment, and
            saves the resulting deletes file (incrementing the
            delete generation for merge.info).  If no deletes were
            flushed, no new deletes file is saved. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.Merge(Lucene.Net.Index.MergePolicy.OneMerge)">
            <summary> Merges the indicated segments, replacing them in the stack with a
            single segment.
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.MergeSuccess(Lucene.Net.Index.MergePolicy.OneMerge)">
            <summary>Hook that's called when the specified merge is complete. </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.RegisterMerge(Lucene.Net.Index.MergePolicy.OneMerge)">
            <summary>Checks whether this merge involves any segments
            already participating in a merge.  If not, this merge
            is "registered", meaning we record that its segments
            are now participating in a merge, and true is
            returned.  Else (the merge conflicts) false is
            returned. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.MergeInit(Lucene.Net.Index.MergePolicy.OneMerge)">
            <summary>Does initial setup for a merge, which is fast but holds
            the synchronized lock on IndexWriter instance.  
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.DoCommitBeforeMergeCFS(Lucene.Net.Index.MergePolicy.OneMerge)">
            <summary>This is called after merging a segment and before
            building its CFS.  Return true if the files should be
            sync'd.  If you return false, then the source segment
            files that were merged cannot be deleted until the CFS
            file is built &amp; sync'd.  So, returning false consumes
            more transient disk space, but saves performance of
            not having to sync files which will shortly be deleted
            anyway.
            </summary>
            <deprecated> -- this will be removed in 3.0 when
            autoCommit is hardwired to false 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.MergeFinish(Lucene.Net.Index.MergePolicy.OneMerge)">
            <summary>Does fininishing for a merge, which is fast but holds
            the synchronized lock on IndexWriter instance. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.MergeMiddle(Lucene.Net.Index.MergePolicy.OneMerge)">
            <summary>Does the actual (time-consuming) work of the merge,
            but without holding synchronized lock on IndexWriter
            instance 
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.WaitForAllSynced(System.Collections.Generic.ICollection{System.String})">
            <summary>Blocks until all files in syncing are sync'd </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.SyncPause(System.Int64)">
            <summary>Pauses before syncing.  On Windows, at least, it's
            best (performance-wise) to pause in order to let OS
            flush writes to disk on its own, before forcing a
            sync.
            </summary>
            <deprecated> -- this will be removed in 3.0 when
            autoCommit is hardwired to false 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.StartCommit(System.Int64,System.Collections.Generic.IDictionary{System.String,System.String})">
            <summary>Walk through all files referenced by the current
            segmentInfos and ask the Directory to sync each file,
            if it wasn't already.  If that succeeds, then we
            prepare a new segments_N file but do not fully commit
            it. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.IsLocked(Lucene.Net.Store.Directory)">
            <summary> Returns <code>true</code> iff the index in the named directory is
            currently locked.
            </summary>
            <param name="directory">the directory to check for a lock
            </param>
            <throws>  IOException if there is a low-level IO error </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.IsLocked(System.String)">
            <summary> Returns <code>true</code> iff the index in the named directory is
            currently locked.
            </summary>
            <param name="directory">the directory to check for a lock
            </param>
            <throws>  IOException if there is a low-level IO error </throws>
            <deprecated> Use {@link #IsLocked(Directory)}
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.Unlock(Lucene.Net.Store.Directory)">
            <summary> Forcibly unlocks the index in the named directory.
            <p/>
            Caution: this should only be used by failure recovery code,
            when it is known that no other process nor thread is in fact
            currently accessing this index.
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.SetMergedSegmentWarmer(Lucene.Net.Index.IndexWriter.IndexReaderWarmer)">
            <summary>Set the merged segment warmer.  See {@link
            IndexReaderWarmer}. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.GetMergedSegmentWarmer">
            <summary>Returns the current merged segment warmer.  See {@link
            IndexReaderWarmer}. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.SetAllowMinus1Position">
            <summary>Deprecated: emulates IndexWriter's buggy behavior when
            first token(s) have positionIncrement==0 (ie, prior to
            fixing LUCENE-1542) 
            </summary>
        </member>
        <member name="T:Lucene.Net.Index.IndexWriter.ReaderPool">
            <summary>Holds shared SegmentReader instances. IndexWriter uses
            SegmentReaders for 1) applying deletes, 2) doing
            merges, 3) handing out a real-time reader.  This pool
            reuses instances of the SegmentReaders in all these
            places if it is in "near real-time mode" (getReader()
            has been called on this instance). 
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.ReaderPool.Clear(Lucene.Net.Index.SegmentInfos)">
            <summary>Forcefully clear changes for the specifed segments,
            and remove from the pool.   This is called on succesful merge. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.ReaderPool.Release(Lucene.Net.Index.SegmentReader)">
            <summary> Release the segment reader (i.e. decRef it and close if there
            are no more references.
            </summary>
            <param name="sr">
            </param>
            <throws>  IOException </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.ReaderPool.Release(Lucene.Net.Index.SegmentReader,System.Boolean)">
            <summary> Release the segment reader (i.e. decRef it and close if there
            are no more references.
            </summary>
            <param name="sr">
            </param>
            <throws>  IOException </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.ReaderPool.Close">
            <summary>Remove all our references to readers, and commits
            any pending changes. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.ReaderPool.Commit">
            <summary> Commit all segment reader in the pool.</summary>
            <throws>  IOException </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.ReaderPool.GetReadOnlyClone(Lucene.Net.Index.SegmentInfo,System.Boolean,System.Int32)">
            <summary> Returns a ref to a clone.  NOTE: this clone is not
            enrolled in the pool, so you should simply close()
            it when you're done (ie, do not call release()).
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.ReaderPool.Get(Lucene.Net.Index.SegmentInfo,System.Boolean)">
            <summary> Obtain a SegmentReader from the readerPool.  The reader
            must be returned by calling {@link #Release(SegmentReader)}
            </summary>
            <seealso cref="M:Lucene.Net.Index.IndexWriter.ReaderPool.Release(Lucene.Net.Index.SegmentReader)">
            </seealso>
            <param name="info">
            </param>
            <param name="doOpenStores">
            </param>
            <throws>  IOException </throws>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.ReaderPool.Get(Lucene.Net.Index.SegmentInfo,System.Boolean,System.Int32,System.Int32)">
            <summary> Obtain a SegmentReader from the readerPool.  The reader
            must be returned by calling {@link #Release(SegmentReader)}
            
            </summary>
            <seealso cref="M:Lucene.Net.Index.IndexWriter.ReaderPool.Release(Lucene.Net.Index.SegmentReader)">
            </seealso>
            <param name="info">
            </param>
            <param name="doOpenStores">
            </param>
            <param name="readBufferSize">
            </param>
            <param name="termsIndexDivisor">
            </param>
            <throws>  IOException </throws>
        </member>
        <member name="T:Lucene.Net.Index.IndexWriter.MaxFieldLength">
            <summary> Specifies maximum field length (in number of tokens/terms) in {@link IndexWriter} constructors.
            {@link #SetMaxFieldLength(int)} overrides the value set by
            the constructor.
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.MaxFieldLength.#ctor(System.String,System.Int32)">
            <summary> Private type-safe-enum-pattern constructor.
            
            </summary>
            <param name="name">instance name
            </param>
            <param name="limit">maximum field length
            </param>
        </member>
        <member name="M:Lucene.Net.Index.IndexWriter.MaxFieldLength.#ctor(System.Int32)">
            <summary> Public constructor to allow users to specify the maximum field size limit.
            
            </summary>
            <param name="limit">The maximum field length
            </param>
        </member>
        <member name="F:Lucene.Net.Index.IndexWriter.MaxFieldLength.UNLIMITED">
            <summary>Sets the maximum field length to {@link Integer#MAX_VALUE}. </summary>
        </member>
        <member name="F:Lucene.Net.Index.IndexWriter.MaxFieldLength.LIMITED">
            <summary>  Sets the maximum field length to 
            {@link #DEFAULT_MAX_FIELD_LENGTH} 
            
            </summary>
        </member>
        <member name="T:Lucene.Net.Index.IndexWriter.IndexReaderWarmer">
            <summary>If {@link #getReader} has been called (ie, this writer
            is in near real-time mode), then after a merge
            completes, this class can be invoked to warm the
            reader on the newly merged segment, before the merge
            commits.  This is not required for near real-time
            search, but will reduce search latency on opening a
            new near real-time reader after a merge completes.
            
            <p/><b>NOTE:</b> This API is experimental and might
            change in incompatible ways in the next release.<p/>
            
            <p/><b>NOTE</b>: warm is called before any deletes have
            been carried over to the merged segment. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.FormatPostingsDocsWriter.AddDoc(System.Int32,System.Int32)">
            <summary>Adds a new doc in this term.  If this returns null
            then we just skip consuming positions/payloads. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.FormatPostingsDocsWriter.Finish">
            <summary>Called when we are done adding docs to this term </summary>
        </member>
        <member name="T:Lucene.Net.Index.FieldInvertState">
            <summary> This class tracks the number and position / offset parameters of terms
            being added to the index. The information collected in this class is
            also used to calculate the normalization factor for a field.
            
            <p/><b>WARNING</b>: This API is new and experimental, and may suddenly
            change.<p/>
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.FieldInvertState.Reset(System.Single)">
            <summary> Re-initialize the state, using this boost value.</summary>
            <param name="docBoost">boost value to use.
            </param>
        </member>
        <member name="M:Lucene.Net.Index.FieldInvertState.GetPosition">
            <summary> Get the last processed term position.</summary>
            <returns> the position
            </returns>
        </member>
        <member name="M:Lucene.Net.Index.FieldInvertState.GetLength">
            <summary> Get total number of terms in this field.</summary>
            <returns> the length
            </returns>
        </member>
        <member name="M:Lucene.Net.Index.FieldInvertState.GetNumOverlap">
            <summary> Get the number of terms with <code>positionIncrement == 0</code>.</summary>
            <returns> the numOverlap
            </returns>
        </member>
        <member name="M:Lucene.Net.Index.FieldInvertState.GetOffset">
            <summary> Get end offset of the last processed term.</summary>
            <returns> the offset
            </returns>
        </member>
        <member name="M:Lucene.Net.Index.FieldInvertState.GetBoost">
            <summary> Get boost value. This is the cumulative product of
            document boost and field boost for all field instances
            sharing the same field name.
            </summary>
            <returns> the boost
            </returns>
        </member>
        <member name="T:Lucene.Net.Documents.DateField">
            <summary> Provides support for converting dates to strings and vice-versa.
            The strings are structured so that lexicographic sorting orders by date,
            which makes them suitable for use as field values and search terms.
            
            <p/>Note that this class saves dates with millisecond granularity,
            which is bad for {@link TermRangeQuery} and {@link PrefixQuery}, as those
            queries are expanded to a BooleanQuery with a potentially large number
            of terms when searching. Thus you might want to use
            {@link DateTools} instead.
            
            <p/>
            Note: dates before 1970 cannot be used, and therefore cannot be
            indexed when using this class. See {@link DateTools} for an
            alternative without such a limitation.
            
            <p/>
            Another approach is {@link NumericUtils}, which provides
            a sortable binary representation (prefix encoded) of numeric values, which
            date/time are.
            For indexing a {@link Date} or {@link Calendar}, just get the unix timestamp as
            <code>long</code> using {@link Date#getTime} or {@link Calendar#getTimeInMillis} and
            index this as a numeric value with {@link NumericField}
            and use {@link NumericRangeQuery} to query it.
            
            </summary>
            <deprecated> If you build a new index, use {@link DateTools} or 
            {@link NumericField} instead.
            This class is included for use with existing
            indices and will be removed in a future release.
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Documents.DateField.DateToString(System.DateTime)">
            <summary> Converts a Date to a string suitable for indexing.</summary>
            <throws>  RuntimeException if the date specified in the </throws>
            <summary> method argument is before 1970
            </summary>
        </member>
        <member name="M:Lucene.Net.Documents.DateField.TimeToString(System.Int64)">
            <summary> Converts a millisecond time to a string suitable for indexing.</summary>
            <throws>  RuntimeException if the time specified in the </throws>
            <summary> method argument is negative, that is, before 1970
            </summary>
        </member>
        <member name="M:Lucene.Net.Documents.DateField.StringToTime(System.String)">
            <summary>Converts a string-encoded date into a millisecond time. </summary>
        </member>
        <member name="M:Lucene.Net.Documents.DateField.StringToDate(System.String)">
            <summary>Converts a string-encoded date into a Date object. </summary>
        </member>
        <member name="T:Lucene.Net.Documents.CompressionTools">
            <summary>Simple utility class providing static methods to
            compress and decompress binary data for stored fields.
            This class uses java.util.zip.Deflater and Inflater
            classes to compress and decompress, which is the same
            format previously used by the now deprecated
            Field.Store.COMPRESS.
            </summary>
        </member>
        <member name="M:Lucene.Net.Documents.CompressionTools.Compress(System.Byte[],System.Int32,System.Int32,System.Int32)">
            <summary>Compresses the specified byte range using the
            specified compressionLevel (constants are defined in
            java.util.zip.Deflater). 
            </summary>
        </member>
        <member name="M:Lucene.Net.Documents.CompressionTools.Compress(System.Byte[],System.Int32,System.Int32)">
            <summary>Compresses the specified byte range, with default BEST_COMPRESSION level </summary>
        </member>
        <member name="M:Lucene.Net.Documents.CompressionTools.Compress(System.Byte[])">
            <summary>Compresses all bytes in the array, with default BEST_COMPRESSION level </summary>
        </member>
        <member name="M:Lucene.Net.Documents.CompressionTools.CompressString(System.String)">
            <summary>Compresses the String value, with default BEST_COMPRESSION level </summary>
        </member>
        <member name="M:Lucene.Net.Documents.CompressionTools.CompressString(System.String,System.Int32)">
            <summary>Compresses the String value using the specified
            compressionLevel (constants are defined in
            java.util.zip.Deflater). 
            </summary>
        </member>
        <member name="M:Lucene.Net.Documents.CompressionTools.Decompress(System.Byte[])">
            <summary>Decompress the byte array previously returned by
            compress 
            </summary>
        </member>
        <member name="M:Lucene.Net.Documents.CompressionTools.DecompressString(System.Byte[])">
            <summary>Decompress the byte array previously returned by
            compressString back into a String 
            </summary>
        </member>
        <member name="T:Lucene.Net.Analysis.Tokenattributes.OffsetAttributeImpl">
            <summary> The start and end character offset of a Token. </summary>
        </member>
        <member name="M:Lucene.Net.Analysis.Tokenattributes.OffsetAttributeImpl.StartOffset">
            <summary>Returns this Token's starting offset, the position of the first character
            corresponding to this token in the source text.
            Note that the difference between endOffset() and startOffset() may not be
            equal to termText.length(), as the term text may have been altered by a
            stemmer or some other filter. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Analysis.Tokenattributes.OffsetAttributeImpl.SetOffset(System.Int32,System.Int32)">
            <summary>Set the starting and ending offset.
            See StartOffset() and EndOffset()
            </summary>
        </member>
        <member name="M:Lucene.Net.Analysis.Tokenattributes.OffsetAttributeImpl.EndOffset">
            <summary>Returns this Token's ending offset, one greater than the position of the
            last character corresponding to this token in the source text. The length
            of the token in the source text is (endOffset - startOffset). 
            </summary>
        </member>
        <member name="T:Lucene.Net.Util.NumericUtils">
            <summary> This is a helper class to generate prefix-encoded representations for numerical values
            and supplies converters to represent float/double values as sortable integers/longs.
            
            <p/>To quickly execute range queries in Apache Lucene, a range is divided recursively
            into multiple intervals for searching: The center of the range is searched only with
            the lowest possible precision in the trie, while the boundaries are matched
            more exactly. This reduces the number of terms dramatically.
            
            <p/>This class generates terms to achive this: First the numerical integer values need to
            be converted to strings. For that integer values (32 bit or 64 bit) are made unsigned
            and the bits are converted to ASCII chars with each 7 bit. The resulting string is
            sortable like the original integer value. Each value is also prefixed
            (in the first char) by the <code>shift</code> value (number of bits removed) used
            during encoding.
            
            <p/>To also index floating point numbers, this class supplies two methods to convert them
            to integer values by changing their bit layout: {@link #doubleToSortableLong},
            {@link #floatToSortableInt}. You will have no precision loss by
            converting floating point numbers to integers and back (only that the integer form
            is not usable). Other data types like dates can easily converted to longs or ints (e.g.
            date to long: {@link java.util.Date#getTime}).
            
            <p/>For easy usage, the trie algorithm is implemented for indexing inside
            {@link NumericTokenStream} that can index <code>int</code>, <code>long</code>,
            <code>float</code>, and <code>double</code>. For querying,
            {@link NumericRangeQuery} and {@link NumericRangeFilter} implement the query part
            for the same data types.
            
            <p/>This class can also be used, to generate lexicographically sortable (according
            {@link String#compareTo(String)}) representations of numeric data types for other
            usages (e.g. sorting).
            
            <p/><font color="red"><b>NOTE:</b> This API is experimental and
            might change in incompatible ways in the next release.</font>
            
            </summary>
            <since> 2.9
            </since>
        </member>
        <member name="F:Lucene.Net.Util.NumericUtils.PRECISION_STEP_DEFAULT">
            <summary> The default precision step used by {@link NumericField}, {@link NumericTokenStream},
            {@link NumericRangeQuery}, and {@link NumericRangeFilter} as default
            </summary>
        </member>
        <member name="F:Lucene.Net.Util.NumericUtils.BUF_SIZE_LONG">
            <summary> Expert: The maximum term length (used for <code>char[]</code> buffer size)
            for encoding <code>long</code> values.
            </summary>
            <seealso cref="M:Lucene.Net.Util.NumericUtils.LongToPrefixCoded(System.Int64,System.Int32,System.Char[])">
            </seealso>
        </member>
        <member name="F:Lucene.Net.Util.NumericUtils.BUF_SIZE_INT">
            <summary> Expert: The maximum term length (used for <code>char[]</code> buffer size)
            for encoding <code>int</code> values.
            </summary>
            <seealso cref="M:Lucene.Net.Util.NumericUtils.IntToPrefixCoded(System.Int32,System.Int32,System.Char[])">
            </seealso>
        </member>
        <member name="F:Lucene.Net.Util.NumericUtils.SHIFT_START_LONG">
            <summary> Expert: Longs are stored at lower precision by shifting off lower bits. The shift count is
            stored as <code>SHIFT_START_LONG+shift</code> in the first character
            </summary>
        </member>
        <member name="F:Lucene.Net.Util.NumericUtils.SHIFT_START_INT">
            <summary> Expert: Integers are stored at lower precision by shifting off lower bits. The shift count is
            stored as <code>SHIFT_START_INT+shift</code> in the first character
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.NumericUtils.LongToPrefixCoded(System.Int64,System.Int32,System.Char[])">
            <summary> Expert: Returns prefix coded bits after reducing the precision by <code>shift</code> bits.
            This is method is used by {@link NumericTokenStream}.
            </summary>
            <param name="val">the numeric value
            </param>
            <param name="shift">how many bits to strip from the right
            </param>
            <param name="buffer">that will contain the encoded chars, must be at least of {@link #BUF_SIZE_LONG}
            length
            </param>
            <returns> number of chars written to buffer
            </returns>
        </member>
        <member name="M:Lucene.Net.Util.NumericUtils.LongToPrefixCoded(System.Int64,System.Int32)">
            <summary> Expert: Returns prefix coded bits after reducing the precision by <code>shift</code> bits.
            This is method is used by {@link LongRangeBuilder}.
            </summary>
            <param name="val">the numeric value
            </param>
            <param name="shift">how many bits to strip from the right
            </param>
        </member>
        <member name="M:Lucene.Net.Util.NumericUtils.LongToPrefixCoded(System.Int64)">
            <summary> This is a convenience method, that returns prefix coded bits of a long without
            reducing the precision. It can be used to store the full precision value as a
            stored field in index.
            <p/>To decode, use {@link #prefixCodedToLong}.
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.NumericUtils.IntToPrefixCoded(System.Int32,System.Int32,System.Char[])">
            <summary> Expert: Returns prefix coded bits after reducing the precision by <code>shift</code> bits.
            This is method is used by {@link NumericTokenStream}.
            </summary>
            <param name="val">the numeric value
            </param>
            <param name="shift">how many bits to strip from the right
            </param>
            <param name="buffer">that will contain the encoded chars, must be at least of {@link #BUF_SIZE_INT}
            length
            </param>
            <returns> number of chars written to buffer
            </returns>
        </member>
        <member name="M:Lucene.Net.Util.NumericUtils.IntToPrefixCoded(System.Int32,System.Int32)">
            <summary> Expert: Returns prefix coded bits after reducing the precision by <code>shift</code> bits.
            This is method is used by {@link IntRangeBuilder}.
            </summary>
            <param name="val">the numeric value
            </param>
            <param name="shift">how many bits to strip from the right
            </param>
        </member>
        <member name="M:Lucene.Net.Util.NumericUtils.IntToPrefixCoded(System.Int32)">
            <summary> This is a convenience method, that returns prefix coded bits of an int without
            reducing the precision. It can be used to store the full precision value as a
            stored field in index.
            <p/>To decode, use {@link #prefixCodedToInt}.
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.NumericUtils.PrefixCodedToLong(System.String)">
            <summary> Returns a long from prefixCoded characters.
            Rightmost bits will be zero for lower precision codes.
            This method can be used to decode e.g. a stored field.
            </summary>
            <throws>  NumberFormatException if the supplied string is </throws>
            <summary> not correctly prefix encoded.
            </summary>
            <seealso cref="M:Lucene.Net.Util.NumericUtils.LongToPrefixCoded(System.Int64)">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Util.NumericUtils.PrefixCodedToInt(System.String)">
            <summary> Returns an int from prefixCoded characters.
            Rightmost bits will be zero for lower precision codes.
            This method can be used to decode e.g. a stored field.
            </summary>
            <throws>  NumberFormatException if the supplied string is </throws>
            <summary> not correctly prefix encoded.
            </summary>
            <seealso cref="M:Lucene.Net.Util.NumericUtils.IntToPrefixCoded(System.Int32)">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Util.NumericUtils.DoubleToSortableLong(System.Double)">
            <summary> Converts a <code>double</code> value to a sortable signed <code>long</code>.
            The value is converted by getting their IEEE 754 floating-point "double format"
            bit layout and then some bits are swapped, to be able to compare the result as long.
            By this the precision is not reduced, but the value can easily used as a long.
            </summary>
            <seealso cref="!:sortableLongToDouble">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Util.NumericUtils.DoubleToPrefixCoded(System.Double)">
            <summary> Convenience method: this just returns:
            longToPrefixCoded(doubleToSortableLong(val))
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.NumericUtils.SortableLongToDouble(System.Int64)">
            <summary> Converts a sortable <code>long</code> back to a <code>double</code>.</summary>
            <seealso cref="!:doubleToSortableLong">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Util.NumericUtils.PrefixCodedToDouble(System.String)">
            <summary> Convenience method: this just returns:
            sortableLongToDouble(prefixCodedToLong(val))
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.NumericUtils.FloatToSortableInt(System.Single)">
            <summary> Converts a <code>float</code> value to a sortable signed <code>int</code>.
            The value is converted by getting their IEEE 754 floating-point "float format"
            bit layout and then some bits are swapped, to be able to compare the result as int.
            By this the precision is not reduced, but the value can easily used as an int.
            </summary>
            <seealso cref="!:sortableIntToFloat">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Util.NumericUtils.FloatToPrefixCoded(System.Single)">
            <summary> Convenience method: this just returns:
            intToPrefixCoded(floatToSortableInt(val))
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.NumericUtils.SortableIntToFloat(System.Int32)">
            <summary> Converts a sortable <code>int</code> back to a <code>float</code>.</summary>
            <seealso cref="!:floatToSortableInt">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Util.NumericUtils.PrefixCodedToFloat(System.String)">
            <summary> Convenience method: this just returns:
            sortableIntToFloat(prefixCodedToInt(val))
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.NumericUtils.SplitLongRange(Lucene.Net.Util.NumericUtils.LongRangeBuilder,System.Int32,System.Int64,System.Int64)">
            <summary> Expert: Splits a long range recursively.
            You may implement a builder that adds clauses to a
            {@link Lucene.Net.Search.BooleanQuery} for each call to its
            {@link LongRangeBuilder#AddRange(String,String)}
            method.
            <p/>This method is used by {@link NumericRangeQuery}.
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.NumericUtils.SplitIntRange(Lucene.Net.Util.NumericUtils.IntRangeBuilder,System.Int32,System.Int32,System.Int32)">
            <summary> Expert: Splits an int range recursively.
            You may implement a builder that adds clauses to a
            {@link Lucene.Net.Search.BooleanQuery} for each call to its
            {@link IntRangeBuilder#AddRange(String,String)}
            method.
            <p/>This method is used by {@link NumericRangeQuery}.
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.NumericUtils.SplitRange(System.Object,System.Int32,System.Int32,System.Int64,System.Int64)">
            <summary>This helper does the splitting for both 32 and 64 bit. </summary>
        </member>
        <member name="M:Lucene.Net.Util.NumericUtils.AddRange(System.Object,System.Int32,System.Int64,System.Int64,System.Int32)">
            <summary>Helper that delegates to correct range builder </summary>
        </member>
        <member name="T:Lucene.Net.Util.NumericUtils.LongRangeBuilder">
            <summary> Expert: Callback for {@link #splitLongRange}.
            You need to overwrite only one of the methods.
            <p/><font color="red"><b>NOTE:</b> This is a very low-level interface,
            the method signatures may change in later versions.</font>
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.NumericUtils.LongRangeBuilder.AddRange(System.String,System.String)">
            <summary> Overwrite this method, if you like to receive the already prefix encoded range bounds.
            You can directly build classical (inclusive) range queries from them.
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.NumericUtils.LongRangeBuilder.AddRange(System.Int64,System.Int64,System.Int32)">
            <summary> Overwrite this method, if you like to receive the raw long range bounds.
            You can use this for e.g. debugging purposes (print out range bounds).
            </summary>
        </member>
        <member name="T:Lucene.Net.Util.NumericUtils.IntRangeBuilder">
            <summary> Expert: Callback for {@link #splitIntRange}.
            You need to overwrite only one of the methods.
            <p/><font color="red"><b>NOTE:</b> This is a very low-level interface,
            the method signatures may change in later versions.</font>
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.NumericUtils.IntRangeBuilder.AddRange(System.String,System.String)">
            <summary> Overwrite this method, if you like to receive the already prefix encoded range bounds.
            You can directly build classical range (inclusive) queries from them.
            </summary>
        </member>
        <member name="M:Lucene.Net.Util.NumericUtils.IntRangeBuilder.AddRange(System.Int32,System.Int32,System.Int32)">
            <summary> Overwrite this method, if you like to receive the raw int range bounds.
            You can use this for e.g. debugging purposes (print out range bounds).
            </summary>
        </member>
        <member name="T:Lucene.Net.Store.NIOFSDirectory">
            <summary>
            Not implemented. Waiting for volunteers.
            </summary>
        </member>
        <member name="T:Lucene.Net.Store.NIOFSDirectory.NIOFSIndexInput">
            <summary>
            Not implemented. Waiting for volunteers.
            </summary>
        </member>
        <member name="T:Lucene.Net.Store.LockStressTest">
            <summary> Simple standalone tool that forever acquires &amp; releases a
            lock using a specific LockFactory.  Run without any args
            to see usage.
            
            </summary>
            <seealso cref="T:Lucene.Net.Store.VerifyingLockFactory">
            </seealso>
            <seealso cref="T:Lucene.Net.Store.LockVerifyServer">
            </seealso>
        </member>
        <member name="T:Lucene.Net.Search.WildcardTermEnum">
            <summary> Subclass of FilteredTermEnum for enumerating all terms that match the
            specified wildcard filter term.
            <p/>
            Term enumerations are always ordered by Term.compareTo().  Each term in
            the enumeration is greater than all that precede it.
            
            </summary>
            <version>  $Id: WildcardTermEnum.java 783371 2009-06-10 14:39:56Z mikemccand $
            </version>
        </member>
        <member name="F:Lucene.Net.Search.WildcardTermEnum.WILDCARD_STRING">
            <summary>*****************************************
            String equality with support for wildcards
            ******************************************
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.WildcardTermEnum.#ctor(Lucene.Net.Index.IndexReader,Lucene.Net.Index.Term)">
            <summary> Creates a new <code>WildcardTermEnum</code>.
            <p/>
            After calling the constructor the enumeration is already pointing to the first 
            valid term if such a term exists.
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.WildcardTermEnum.WildcardEquals(System.String,System.Int32,System.String,System.Int32)">
            <summary> Determines if a word matches a wildcard pattern.
            <small>Work released by Granta Design Ltd after originally being done on
            company time.</small>
            </summary>
        </member>
        <member name="T:Lucene.Net.Search.TopDocs">
            <summary> Represents hits returned by {@link
            * Searcher#search(Query,Filter,int)} and {@link
            * Searcher#search(Query,int)
            </summary>
        </member>
        <member name="F:Lucene.Net.Search.TopDocs.totalHits">
            <summary>The total number of hits for the query.</summary>
            <seealso cref="M:Lucene.Net.Search.Hits.Length">
            </seealso>
        </member>
        <member name="F:Lucene.Net.Search.TopDocs.scoreDocs">
            <summary>The top hits for the query. </summary>
        </member>
        <member name="F:Lucene.Net.Search.TopDocs.maxScore">
            <summary>Stores the maximum score value encountered, needed for normalizing. </summary>
        </member>
        <member name="M:Lucene.Net.Search.TopDocs.GetMaxScore">
            <summary>Returns the maximum score value encountered. Note that in case
            scores are not tracked, this returns {@link Float#NaN}.
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.TopDocs.SetMaxScore(System.Single)">
            <summary>Sets the maximum score value encountered. </summary>
        </member>
        <member name="M:Lucene.Net.Search.TopDocs.#ctor(System.Int32,Lucene.Net.Search.ScoreDoc[])">
            <summary>Constructs a TopDocs with a default maxScore=Float.NaN. </summary>
        </member>
        <member name="M:Lucene.Net.Search.TopDocs.#ctor(System.Int32,Lucene.Net.Search.ScoreDoc[],System.Single)">
            <summary></summary>
        </member>
        <member name="T:Lucene.Net.Search.Spans.SpanTermQuery">
            <summary>Matches spans containing a term. </summary>
        </member>
        <member name="M:Lucene.Net.Search.Spans.SpanTermQuery.#ctor(Lucene.Net.Index.Term)">
            <summary>Construct a SpanTermQuery matching the named term's spans. </summary>
        </member>
        <member name="M:Lucene.Net.Search.Spans.SpanTermQuery.GetTerm">
            <summary>Return the term whose spans are matched. </summary>
        </member>
        <member name="M:Lucene.Net.Search.Spans.SpanTermQuery.GetTerms">
            <summary>Returns a collection of all terms matched by this query.</summary>
            <deprecated> use extractTerms instead
            </deprecated>
            <seealso cref="!:ExtractTerms(Set)">
            </seealso>
        </member>
        <member name="T:Lucene.Net.Search.Spans.NearSpansUnordered">
            <summary> Similar to {@link NearSpansOrdered}, but for the unordered case.
            
            Expert:
            Only public for subclassing.  Most implementations should not need this class
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.Spans.NearSpansUnordered.GetPayload">
            <summary> WARNING: The List is not necessarily in order of the the positions</summary>
            <returns> Collection of <code>byte[]</code> payloads
            </returns>
            <throws>  IOException </throws>
        </member>
        <member name="T:Lucene.Net.Search.Spans.NearSpansUnordered.SpansCell">
            <summary>Wraps a Spans, and can be used to form a linked list. </summary>
        </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.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="T:Lucene.Net.Search.MatchAllDocsQuery">
            <summary> A query that matches all documents.
            
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.MatchAllDocsQuery.#ctor(System.String)">
            <param name="normsField">Field used for normalization factor (document boost). Null if nothing.
            </param>
        </member>
        <member name="M:Lucene.Net.Search.MatchAllDocsQuery.MatchAllScorer.Doc">
            <deprecated> use {@link #DocID()} instead. 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.MatchAllDocsQuery.MatchAllScorer.Next">
            <deprecated> use {@link #NextDoc()} instead. 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.MatchAllDocsQuery.MatchAllScorer.SkipTo(System.Int32)">
            <deprecated> use {@link #Advance(int)} instead. 
            </deprecated>
        </member>
        <member name="T:Lucene.Net.Search.Function.OrdFieldSource">
            <summary> Expert: obtains the ordinal of the field value from the default Lucene 
            {@link Lucene.Net.Search.FieldCache Fieldcache} using getStringIndex().
            <p/>
            The native lucene index order is used to assign an ordinal value for each field value.
            <p/>
            Field values (terms) are lexicographically ordered by unicode value, and numbered starting at 1.
            <p/>
            Example:
            <br/>If there were only three field values: "apple","banana","pear"
            <br/>then ord("apple")=1, ord("banana")=2, ord("pear")=3
            <p/>
            WARNING: 
            ord() depends on the position in an index and can thus change 
            when other documents are inserted or deleted,
            or if a MultiSearcher is used. 
            
            <p/><font color="#FF0000">
            WARNING: The status of the <b>Search.Function</b> package is experimental. 
            The APIs introduced here might change in the future and will not be 
            supported anymore in such a case.</font>
            
            <p/><b>NOTE</b>: with the switch in 2.9 to segment-based
            searching, if {@link #getValues} is invoked with a
            composite (multi-segment) reader, this can easily cause
            double RAM usage for the values in the FieldCache.  It's
            best to switch your application to pass only atomic
            (single segment) readers to this API.  Alternatively, for
            a short-term fix, you could wrap your ValueSource using
            {@link MultiValueSource}, which costs more CPU per lookup
            but will not consume double the FieldCache RAM.<p/>
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.Function.OrdFieldSource.#ctor(System.String)">
            <summary> Constructor for a certain field.</summary>
            <param name="field">field whose values order is used.  
            </param>
        </member>
        <member name="T:Lucene.Net.Search.DisjunctionMaxScorer">
            <summary> The Scorer for DisjunctionMaxQuery's.  The union of all documents generated by the the subquery scorers
            is generated in document number order.  The score for each document is the maximum of the scores computed
            by the subquery scorers that generate that document, plus tieBreakerMultiplier times the sum of the scores
            for the other subqueries that generate the document.
            </summary>
        </member>
        <member name="M:Lucene.Net.Search.DisjunctionMaxScorer.#ctor(System.Single,Lucene.Net.Search.Similarity,Lucene.Net.Search.Scorer[],System.Int32)">
            <summary> Creates a new instance of DisjunctionMaxScorer
            
            </summary>
            <param name="tieBreakerMultiplier">Multiplier applied to non-maximum-scoring subqueries for a
            document as they are summed into the result.
            </param>
            <param name="similarity">-- not used since our definition involves neither coord nor terms
            directly
            </param>
            <param name="subScorers">The sub scorers this Scorer should iterate on
            </param>
            <param name="numScorers">The actual number of scorers to iterate on. Note that the array's
            length may be larger than the actual number of scorers.
            </param>
        </member>
        <member name="M:Lucene.Net.Search.DisjunctionMaxScorer.Next">
            <summary> Generate the next document matching our associated DisjunctionMaxQuery.
            
            </summary>
            <returns> true iff there is a next document
            </returns>
            <deprecated> use {@link #NextDoc()} instead.
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.DisjunctionMaxScorer.Doc">
            <deprecated> use {@link #DocID()} instead. 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.DisjunctionMaxScorer.Score">
            <summary>Determine the current document score.  Initially invalid, until {@link #Next()} is called the first time.</summary>
            <returns> the score of the current generated document
            </returns>
        </member>
        <member name="M:Lucene.Net.Search.DisjunctionMaxScorer.SkipTo(System.Int32)">
            <summary> Advance to the first document beyond the current whose number is greater
            than or equal to target.
            
            </summary>
            <param name="target">the minimum number of the next desired document
            </param>
            <returns> true iff there is a document to be generated whose number is at
            least target
            </returns>
            <deprecated> use {@link #Advance(int)} instead.
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.DisjunctionMaxScorer.Explain(System.Int32)">
            <summary>Explain a score that we computed.  UNSUPPORTED -- see explanation capability in DisjunctionMaxQuery.</summary>
            <param name="doc">the number of a document we scored
            </param>
            <returns> the Explanation for our score
            </returns>
        </member>
        <member name="T:Lucene.Net.Search.ConstantScoreRangeQuery">
            <summary> A range query that returns a constant score equal to its boost for
            all documents in the exclusive range of terms.
            
            <p/>It does not have an upper bound on the number of clauses covered in the range.
            
            <p/>This query matches the documents looking for terms that fall into the
            supplied range according to {@link String#compareTo(String)}. It is not intended
            for numerical ranges, use {@link NumericRangeQuery} instead.
            
            <p/>This query is hardwired to {@link MultiTermQuery#CONSTANT_SCORE_AUTO_REWRITE_DEFAULT}.
            If you want to change this, use {@link TermRangeQuery} instead.
            
            </summary>
            <deprecated> Use {@link TermRangeQuery} for term ranges or
            {@link NumericRangeQuery} for numeric ranges instead.
            This class will be removed in Lucene 3.0.
            </deprecated>
            <version>  $Id: ConstantScoreRangeQuery.java 797694 2009-07-25 00:03:33Z mikemccand $
            </version>
        </member>
        <member name="T:Lucene.Net.Search.TermRangeQuery">
            <summary> A Query that matches documents within an exclusive range of terms.
            
            <p/>This query matches the documents looking for terms that fall into the
            supplied range according to {@link String#compareTo(String)}. It is not intended
            for numerical ranges, use {@link NumericRangeQuery} instead.
            
            <p/>This query uses the {@link
            MultiTermQuery#CONSTANT_SCORE_AUTO_REWRITE_DEFAULT}
            rewrite method.
            </summary>
            <since> 2.9
            </since>
        </member>
        <member name="T:Lucene.Net.Search.MultiTermQuery">
            <summary> An abstract {@link Query} that matches documents
            containing a subset of terms provided by a {@link
            FilteredTermEnum} enumeration.
            
            <p/>This query cannot be used directly; you must subclass
            it and define {@link #getEnum} to provide a {@link
            FilteredTermEnum} that iterates through the terms to be
            matched.
            
            <p/><b>NOTE</b>: if {@link #setRewriteMethod} is either
            {@link #CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE} or {@link
            #SCORING_BOOLEAN_QUERY_REWRITE}, you may encounter a
            {@link BooleanQuery.TooManyClauses} exception during
            searching, which happens when the number of terms to be
            searched exceeds {@link
            BooleanQuery#GetMaxClauseCount()}.  Setting {@link
            #setRewriteMethod} to {@link #CONSTANT_SCORE_FILTER_REWRITE}
            prevents this.
            
            <p/>The recommended rewrite method is {@link
            #CONSTANT_SCORE_AUTO_REWRITE_DEFAULT}: it doesn't spend CPU
            computing unhelpful scores, and it tries to pick the most
            performant rewrite method given the query.
            
            Note that {@link QueryParser} produces
            MultiTermQueries using {@link
            #CONSTANT_SCORE_AUTO_REWRITE_DEFAULT} by default.
            </summary>
        </member>
        <member name="F:Lucene.Net.Search.MultiTermQuery.CONSTANT_SCORE_FILTER_REWRITE">
            <summary>A rewrite method that first creates a private Filter,
            by visiting each term in sequence and marking all docs
            for that term.  Matching documents are assigned a
            constant score equal to the query's boost.
            
            <p/> This method is faster than the BooleanQuery
            rewrite methods when the number of matched terms or
            matched documents is non-trivial. Also, it will never
            hit an errant {@link BooleanQuery.TooManyClauses}
            exception.
            
            </summary>
            <seealso cref="!:setRewriteMethod">
            </seealso>
        </member>
        <member name="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>
        </member>
        <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>
        </member>
        <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.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.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.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.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.MultiTermQuery.GetRewriteMethod">
            <seealso cref="!:setRewriteMethod">
            </seealso>
        </member>
        <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.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="T:Lucene.Net.Search.MultiTermQuery.RewriteMethod">
            <summary>Abstract class that defines how the query is rewritten. </summary>
        </member>
        <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>
        </member>
        <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="percent">0.0 to 100.0 
            </param>
        </member>
        <member name="M:Lucene.Net.Search.MultiTermQuery.ConstantScoreAutoRewrite.GetDocCountPercent">
            <seealso cref="!:setDocCountPercent">
            </seealso>
        </member>
        <member name="M:Lucene.Net.Search.TermRangeQuery.#ctor(System.String,System.String,System.String,System.Boolean,System.Boolean)">
            <summary> Constructs a query selecting all terms greater/equal than <code>lowerTerm</code>
            but less/equal than <code>upperTerm</code>. 
            
            <p/>
            If an endpoint is null, it is said 
            to be "open". Either or both endpoints may be open.  Open endpoints may not 
            be exclusive (you can't select all but the first or last term without 
            explicitly specifying the term to exclude.)
            
            </summary>
            <param name="field">The field that holds both lower and upper terms.
            </param>
            <param name="lowerTerm">The term text at the lower end of the range
            </param>
            <param name="upperTerm">The term text at the upper end of the range
            </param>
            <param name="includeLower">If true, the <code>lowerTerm</code> is
            included in the range.
            </param>
            <param name="includeUpper">If true, the <code>upperTerm</code> is
            included in the range.
            </param>
        </member>
        <member name="M:Lucene.Net.Search.TermRangeQuery.#ctor(System.String,System.String,System.String,System.Boolean,System.Boolean,System.Globalization.CompareInfo)">
            <summary>Constructs a query selecting all terms greater/equal than
            <code>lowerTerm</code> but less/equal than <code>upperTerm</code>.
            <p/>
            If an endpoint is null, it is said 
            to be "open". Either or both endpoints may be open.  Open endpoints may not 
            be exclusive (you can't select all but the first or last term without 
            explicitly specifying the term to exclude.)
            <p/>
            If <code>collator</code> is not null, it will be used to decide whether
            index terms are within the given range, rather than using the Unicode code
            point order in which index terms are stored.
            <p/>
            <strong>WARNING:</strong> Using this constructor and supplying a non-null
            value in the <code>collator</code> parameter will cause every single 
            index Term in the Field referenced by lowerTerm and/or upperTerm to be
            examined.  Depending on the number of index Terms in this Field, the 
            operation could be very slow.
            
            </summary>
            <param name="lowerTerm">The Term text at the lower end of the range
            </param>
            <param name="upperTerm">The Term text at the upper end of the range
            </param>
            <param name="includeLower">If true, the <code>lowerTerm</code> is
            included in the range.
            </param>
            <param name="includeUpper">If true, the <code>upperTerm</code> is
            included in the range.
            </param>
            <param name="collator">The collator to use to collate index Terms, to determine
            their membership in the range bounded by <code>lowerTerm</code> and
            <code>upperTerm</code>.
            </param>
        </member>
        <member name="M:Lucene.Net.Search.TermRangeQuery.GetField">
            <summary>Returns the field name for this query </summary>
        </member>
        <member name="M:Lucene.Net.Search.TermRangeQuery.GetLowerTerm">
            <summary>Returns the lower value of this range query </summary>
        </member>
        <member name="M:Lucene.Net.Search.TermRangeQuery.GetUpperTerm">
            <summary>Returns the upper value of this range query </summary>
        </member>
        <member name="M:Lucene.Net.Search.TermRangeQuery.IncludesLower">
            <summary>Returns <code>true</code> if the lower endpoint is inclusive </summary>
        </member>
        <member name="M:Lucene.Net.Search.TermRangeQuery.IncludesUpper">
            <summary>Returns <code>true</code> if the upper endpoint is inclusive </summary>
        </member>
        <member name="M:Lucene.Net.Search.TermRangeQuery.GetCollator">
            <summary>Returns the collator used to determine range inclusion, if any. </summary>
        </member>
        <member name="M:Lucene.Net.Search.TermRangeQuery.ToString(System.String)">
            <summary>Prints a user-readable version of this query. </summary>
        </member>
        <member name="M:Lucene.Net.Search.ConstantScoreRangeQuery.SetRewriteMethod(Lucene.Net.Search.MultiTermQuery.RewriteMethod)">
            <summary>Changes of mode are not supported by this class (fixed to constant score rewrite mode) </summary>
        </member>
        <member name="M:Lucene.Net.Search.BooleanScorer.Score(Lucene.Net.Search.HitCollector,System.Int32)">
            <deprecated> use {@link #Score(Collector, int, int)} instead. 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.BooleanScorer.Doc">
            <deprecated> use {@link #DocID()} instead. 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.BooleanScorer.Next">
            <deprecated> use {@link #NextDoc()} instead. 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.BooleanScorer.Score(Lucene.Net.Search.HitCollector)">
            <deprecated> use {@link #Score(Collector)} instead. 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.BooleanScorer.SkipTo(System.Int32)">
            <deprecated> use {@link #Advance(int)} instead. 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.BooleanScorer.BucketScorer.Doc">
            <deprecated> use {@link #DocID()} instead. 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.BooleanScorer.BucketScorer.Next">
            <deprecated> use {@link #NextDoc()} instead. 
            </deprecated>
        </member>
        <member name="M:Lucene.Net.Search.BooleanScorer.BucketScorer.SkipTo(System.Int32)">
            <deprecated> use {@link #Advance(int)} instead. 
            </deprecated>
        </member>
        <member name="T:Lucene.Net.Search.BooleanScorer.BucketTable">
            <summary>A simple hash table of document scores within a range. </summary>
        </member>
        <member name="T:Lucene.Net.Index.SerialMergeScheduler">
            <summary>A {@link MergeScheduler} that simply does each merge
            sequentially, using the current thread. 
            </summary>
        </member>
        <member name="T:Lucene.Net.Index.MergeScheduler">
            <summary><p/>Expert: {@link IndexWriter} uses an instance
            implementing this interface to execute the merges
            selected by a {@link MergePolicy}.  The default
            MergeScheduler is {@link ConcurrentMergeScheduler}.<p/>
            
            <p/><b>NOTE:</b> This API is new and still experimental
            (subject to change suddenly in the next release)<p/>
            
            <p/><b>NOTE</b>: This class typically requires access to
            package-private APIs (eg, SegmentInfos) to do its job;
            if you implement your own MergePolicy, you'll need to put
            it in package Lucene.Net.Index in order to use
            these APIs.
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.MergeScheduler.Merge(Lucene.Net.Index.IndexWriter)">
            <summary>Run the merges provided by {@link IndexWriter#GetNextMerge()}. </summary>
        </member>
        <member name="M:Lucene.Net.Index.MergeScheduler.Close">
            <summary>Close this MergeScheduler. </summary>
        </member>
        <member name="M:Lucene.Net.Index.SerialMergeScheduler.Merge(Lucene.Net.Index.IndexWriter)">
            <summary>Just do the merges in sequence. We do this
            "synchronized" so that even if the application is using
            multiple threads, only one merge may run at a time. 
            </summary>
        </member>
        <member name="T:Lucene.Net.Index.ReusableStringReader">
            <summary>Used by DocumentsWriter to implemented a StringReader
            that can be reset to a new string; we use this when
            tokenizing the string value from a Field. 
            </summary>
        </member>
        <member name="T:Lucene.Net.Index.DocFieldProcessorPerThread">
            <summary> Gathers all Fieldables for a document under the same
            name, updates FieldInfos, and calls per-field consumers
            to process field by field.
            
            Currently, only a single thread visits the fields,
            sequentially, for processing.
            </summary>
        </member>
        <member name="M:Lucene.Net.Index.DocFieldProcessorPerThread.TrimFields(Lucene.Net.Index.SegmentWriteState)">
            <summary>If there are fields we've seen but did not see again
            in the last run, then free them up. 
            </summary>
        </member>
        <member name="T:Lucene.Net.Documents.MapFieldSelector">
            <summary> A {@link FieldSelector} based on a Map of field names to {@link FieldSelectorResult}s
            
            </summary>
        </member>
        <member name="M:Lucene.Net.Documents.MapFieldSelector.#ctor(System.Collections.IDictionary)">
            <summary>Create a a MapFieldSelector</summary>
            <param name="fieldSelections">maps from field names (String) to {@link FieldSelectorResult}s
            </param>
        </member>
        <member name="M:Lucene.Net.Documents.MapFieldSelector.#ctor(System.Collections.IList)">
            <summary>Create a a MapFieldSelector</summary>
            <param name="fields">fields to LOAD.  List of Strings.  All other fields are NO_LOAD.
            </param>
        </member>
        <member name="M:Lucene.Net.Documents.MapFieldSelector.#ctor(System.String[])">
            <summary>Create a a MapFieldSelector</summary>
            <param name="fields">fields to LOAD.  All other fields are NO_LOAD.
            </param>
        </member>
        <member name="M:Lucene.Net.Documents.MapFieldSelector.Accept(System.String)">
            <summary>Load field according to its associated value in fieldSelections</summary>
            <param name="field">a field name
            </param>
            <returns> the fieldSelections value that field maps to or NO_LOAD if none.
            </returns>
        </member>
        <member name="T:Lucene.Net.Analysis.NumericTokenStream">
            <summary> <b>Expert:</b> This class provides a {@link TokenStream}
            for indexing numeric values that can be used by {@link
            NumericRangeQuery} or {@link NumericRangeFilter}.
            
            <p/>Note that for simple usage, {@link NumericField} is
            recommended.  {@link NumericField} disables norms and
            term freqs, as they are not usually needed during
            searching.  If you need to change these settings, you
            should use this class.
            
            <p/>See {@link NumericField} for capabilities of fields
            indexed numerically.<p/>
            
            <p/>Here's an example usage, for an <code>int</code> field:
            
            <pre>
             Field field = new Field(name, new NumericTokenStream(precisionStep).setIntValue(value));
             field.setOmitNorms(true);
             field.setOmitTermFreqAndPositions(true);
             document.add(field);
            </pre>
            
            <p/>For optimal performance, re-use the TokenStream and Field instance
            for more than one document:
            
            <pre>
             NumericTokenStream stream = new NumericTokenStream(precisionStep);
             Field field = new Field(name, stream);
             field.setOmitNorms(true);
             field.setOmitTermFreqAndPositions(true);
             Document document = new Document();
             document.add(field);
            
             for(all documents) {
               stream.setIntValue(value)
               writer.addDocument(document);
             }
            </pre>
            
            <p/>This stream is not intended to be used in analyzers;
            it's more for iterating the different precisions during
            indexing a specific numeric value.<p/>
            
            <p/><b>NOTE</b>: as token streams are only consumed once
            the document is added to the index, if you index more
            than one numeric field, use a separate <code>NumericTokenStream</code>
            instance for each.<p/>
            
            <p/>See {@link NumericRangeQuery} for more details on the
            <a
            href="../search/NumericRangeQuery.html#precisionStepDesc"><code>precisionStep</code></a>
            parameter as well as how numeric fields work under the hood.<p/>
            
            <p/><font color="red"><b>NOTE:</b> This API is experimental and
            might change in incompatible ways in the next release.</font>
            
            </summary>
            <since> 2.9
            </since>
        </member>
        <member name="F:Lucene.Net.Analysis.NumericTokenStream.TOKEN_TYPE_FULL_PREC">
            <summary>The full precision token gets this token type assigned. </summary>
        </member>
        <member name="F:Lucene.Net.Analysis.NumericTokenStream.TOKEN_TYPE_LOWER_PREC">
            <summary>The lower precision tokens gets this token type assigned. </summary>
        </member>
        <member name="M:Lucene.Net.Analysis.NumericTokenStream.#ctor">
            <summary> Creates a token stream for numeric values using the default <code>precisionStep</code>
            {@link NumericUtils#PRECISION_STEP_DEFAULT} (4). The stream is not yet initialized,
            before using set a value using the various set<em>???</em>Value() methods.
            </summary>
        </member>
        <member name="M:Lucene.Net.Analysis.NumericTokenStream.#ctor(System.Int32)">
            <summary> Creates a token stream for numeric values with the specified
            <code>precisionStep</code>. The stream is not yet initialized,
            before using set a value using the various set<em>???</em>Value() methods.
            </summary>
        </member>
        <member name="M:Lucene.Net.Analysis.NumericTokenStream.#ctor(Lucene.Net.Util.AttributeSource,System.Int32)">
            <summary> Expert: Creates a token stream for numeric values with the specified
            <code>precisionStep</code> using the given {@link AttributeSource}.
            The stream is not yet initialized,
            before using set a value using the various set<em>???</em>Value() methods.
            </summary>
        </member>
        <member name="M:Lucene.Net.Analysis.NumericTokenStream.#ctor(Lucene.Net.Util.AttributeSource.AttributeFactory,System.Int32)">
            <summary> Expert: Creates a token stream for numeric values with the specified
            <code>precisionStep</code> using the given
            {@link org.apache.lucene.util.AttributeSource.AttributeFactory}.
            The stream is not yet initialized,
            before using set a value using the various set<em>???</em>Value() methods.
            </summary>
        </member>
        <member name="M:Lucene.Net.Analysis.NumericTokenStream.SetLongValue(System.Int64)">
            <summary> Initializes the token stream with the supplied <code>long</code> value.</summary>
            <param name="value">the value, for which this TokenStream should enumerate tokens.
            </param>
            <returns> this instance, because of this you can use it the following way:
            <code>new Field(name, new NumericTokenStream(precisionStep).SetLongValue(value))</code>
            </returns>
        </member>
        <member name="M:Lucene.Net.Analysis.NumericTokenStream.SetIntValue(System.Int32)">
            <summary> Initializes the token stream with the supplied <code>int</code> value.</summary>
            <param name="value">the value, for which this TokenStream should enumerate tokens.
            </param>
            <returns> this instance, because of this you can use it the following way:
            <code>new Field(name, new NumericTokenStream(precisionStep).SetIntValue(value))</code>
            </returns>
        </member>
        <member name="M:Lucene.Net.Analysis.NumericTokenStream.SetDoubleValue(System.Double)">
            <summary> Initializes the token stream with the supplied <code>double</code> value.</summary>
            <param name="value">the value, for which this TokenStream should enumerate tokens.
            </param>
            <returns> this instance, because of this you can use it the following way:
            <code>new Field(name, new NumericTokenStream(precisionStep).SetDoubleValue(value))</code>
            </returns>
        </member>
        <member name="M:Lucene.Net.Analysis.NumericTokenStream.SetFloatValue(System.Single)">
            <summary> Initializes the token stream with the supplied <code>float</code> value.</summary>
            <param name="value">the value, for which this TokenStream should enumerate tokens.
            </param>
            <returns> this instance, because of this you can use it the following way:
            <code>new Field(name, new NumericTokenStream(precisionStep).SetFloatValue(value))</code>
            </returns>
        </member>
        <member name="T:Lucene.Net.Analysis.NormalizeCharMap">
            <summary> Holds a map of String input to String output, to be used
            with {@link MappingCharFilter}.
            </summary>
        </member>
        <member name="M:Lucene.Net.Analysis.NormalizeCharMap.Add(System.String,System.String)">
            <summary>Records a replacement to be applied to the inputs
            stream.  Whenever <code>singleMatch</code> occurs in
            the input, it will be replaced with
            <code>replacement</code>.
            
            </summary>
            <param name="singleMatch">input String to be replaced
            </param>
            <param name="replacement">output String
            </param>
        </member>
        <member name="T:Lucene.Net.Util.SmallFloat">
            <summary>Floating point numbers smaller than 32 bits.
            
            </summary>
            <version>  $Id$
            </version>
        </member>
        <