<?xml version="1.0"?>
<doc>
    <assembly>
        <name>Lucene.Net.Facet</name>
    </assembly>
    <members>
        <member name="T:Lucene.Net.Facet.DrillDownQuery">
            <summary>
            A <see cref="T:Lucene.Net.Search.Query"/> for drill-down over facet categories. You
            should call <see cref="M:Lucene.Net.Facet.DrillDownQuery.Add(System.String,System.String[])"/> for every group of categories you
            want to drill-down over.
            <para/>
            <b>NOTE:</b> if you choose to create your own <see cref="T:Lucene.Net.Search.Query"/> by calling
            <see cref="M:Lucene.Net.Facet.DrillDownQuery.Term(System.String,System.String,System.String[])"/>, it is recommended to wrap it with <see cref="T:Lucene.Net.Search.ConstantScoreQuery"/>
            and set the <see cref="P:Lucene.Net.Search.Query.Boost">boost</see> to <c>0.0f</c>,
            so that it does not affect the scores of the documents.
            <para/>
            Collection initializer note: To create and populate a <see cref="T:Lucene.Net.Facet.DrillDownQuery"/>
            in a single statement, you can use the following example as a guide:
            
            <code>
            var drillDownQuery = new DrillDownQuery(config)
            {
                { "Publish Date", "2019" },
                { "Publish Date", "2020" },
                { "Publish Date", "2021" },
                { "timestamp", NumericRangeQuery.NewInt64Range("timestamp", range.Min, range.Max, range.MinInclusive, range.MaxInclusive) },
                { "filter", GetFilter() }
            };
            </code>
            <para/>
            @lucene.experimental
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.DrillDownQuery.Term(System.String,System.String,System.String[])">
            <summary>
            Creates a drill-down term.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.DrillDownQuery.#ctor(Lucene.Net.Facet.FacetsConfig,Lucene.Net.Search.BooleanQuery,System.Collections.Generic.IDictionary{System.String,System.Int32})">
            <summary>
            Used by <see cref="M:Lucene.Net.Facet.DrillDownQuery.Clone"/>
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.DrillDownQuery.#ctor(Lucene.Net.Facet.FacetsConfig,Lucene.Net.Search.Filter,Lucene.Net.Facet.DrillDownQuery)">
            <summary>
            Used by <see cref="T:Lucene.Net.Facet.DrillSideways"/>
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.DrillDownQuery.#ctor(Lucene.Net.Facet.FacetsConfig,Lucene.Net.Search.Query,System.Collections.Generic.IList{Lucene.Net.Search.Query},System.Collections.Generic.IDictionary{System.String,System.Int32})">
            <summary>
            Used by <see cref="T:Lucene.Net.Facet.DrillSideways"/>
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.DrillDownQuery.#ctor(Lucene.Net.Facet.FacetsConfig)">
            <summary>
            Creates a new <see cref="T:Lucene.Net.Facet.DrillDownQuery"/> without a base query, 
            to perform a pure browsing query (equivalent to using
            <see cref="T:Lucene.Net.Search.MatchAllDocsQuery"/> as base). 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.DrillDownQuery.#ctor(Lucene.Net.Facet.FacetsConfig,Lucene.Net.Search.Query)">
            <summary>
            Creates a new <see cref="T:Lucene.Net.Facet.DrillDownQuery"/> over the given base query. Can be
            <c>null</c>, in which case the result <see cref="T:Lucene.Net.Search.Query"/> from
            <see cref="M:Lucene.Net.Facet.DrillDownQuery.Rewrite(Lucene.Net.Index.IndexReader)"/> will be a pure browsing query, filtering on
            the added categories only. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.DrillDownQuery.Merge(System.String,System.String[])">
            <summary>
            Merges (ORs) a new path into an existing AND'd
            clause. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.DrillDownQuery.Add(System.String,System.String[])">
            <summary>
            Adds one dimension of drill downs; if you pass the same
            dimension more than once it is OR'd with the previous
            cofnstraints on that dimension, and all dimensions are
            AND'd against each other and the base query. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.DrillDownQuery.Add(System.String,Lucene.Net.Search.Query)">
            <summary>
            Expert: add a custom drill-down subQuery.  Use this
            when you have a separate way to drill-down on the
            dimension than the indexed facet ordinals. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.DrillDownQuery.Add(System.String,Lucene.Net.Search.Filter)">
            <summary>
            Expert: add a custom drill-down Filter, e.g. when
            drilling down after range faceting. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.DrillDownQuery.GetEnumerator">
            <summary>
            Returns an iterator on the clauses in this query. It implements the <see cref="T:IEnumerable{BooleanClause}"/> interface to
            make it possible to do:
            <code>foreach (BooleanClause clause in drillDownQuery) {}</code>
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.DrillDownQuery.System#Collections#Generic#IEnumerable{System#Collections#Generic#KeyValuePair{System#String,System#Int32}}#GetEnumerator">
            <summary>
            Returns an iterator on the dims in this query. It implements the <see cref="T:IEnumerable{KeyValuePair{string, int}}"/> interface to
            make it possible to do:
            <code>
            foreach (KeyValuePair&lt;string, int&gt; dimensionAndCount in (IEnumerable&lt;KeyValuePair&lt;string, int&gt;&gt;)drillDownQuery) {}
            </code>
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.DrillSideways">
            <summary>
            Computes drill down and sideways counts for the provided
            <see cref="T:Lucene.Net.Facet.DrillDownQuery"/>.  Drill sideways counts include
            alternative values/aggregates for the drill-down
            dimensions so that a dimension does not disappear after
            the user drills down into it.
            
            <para> Use one of the static search
            methods to do the search, and then get the hits and facet
            results from the returned <see cref="T:Lucene.Net.Facet.DrillSidewaysResult"/>.
            
            </para>
            <para><b>NOTE</b>: this allocates one <see cref="T:Lucene.Net.Facet.FacetsCollector"/>
            for each drill-down, plus one.  If your
            index has high number of facet labels then this will
            multiply your memory usage.
            
            @lucene.experimental
            </para>
            </summary>
        </member>
        <member name="F:Lucene.Net.Facet.DrillSideways.m_searcher">
            <summary>
            <see cref="T:Lucene.Net.Search.IndexSearcher"/> passed to constructor.
            </summary>
        </member>
        <member name="F:Lucene.Net.Facet.DrillSideways.m_taxoReader">
            <summary>
            <see cref="T:Lucene.Net.Facet.Taxonomy.TaxonomyReader"/> passed to constructor.
            </summary>
        </member>
        <member name="F:Lucene.Net.Facet.DrillSideways.m_state">
            <summary>
            <see cref="T:Lucene.Net.Facet.SortedSet.SortedSetDocValuesReaderState"/> passed to
            constructor; can be <c>null</c>. 
            </summary>
        </member>
        <member name="F:Lucene.Net.Facet.DrillSideways.m_config">
            <summary>
            <see cref="T:Lucene.Net.Facet.FacetsConfig"/> passed to constructor.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.DrillSideways.#ctor(Lucene.Net.Search.IndexSearcher,Lucene.Net.Facet.FacetsConfig,Lucene.Net.Facet.Taxonomy.TaxonomyReader)">
            <summary>
            Create a new <see cref="T:Lucene.Net.Facet.DrillSideways"/> instance.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.DrillSideways.#ctor(Lucene.Net.Search.IndexSearcher,Lucene.Net.Facet.FacetsConfig,Lucene.Net.Facet.SortedSet.SortedSetDocValuesReaderState)">
            <summary>
            Create a new <see cref="T:Lucene.Net.Facet.DrillSideways"/> instance, assuming the categories were
            indexed with <see cref="T:Lucene.Net.Facet.SortedSet.SortedSetDocValuesFacetField"/>. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.DrillSideways.#ctor(Lucene.Net.Search.IndexSearcher,Lucene.Net.Facet.FacetsConfig,Lucene.Net.Facet.Taxonomy.TaxonomyReader,Lucene.Net.Facet.SortedSet.SortedSetDocValuesReaderState)">
            <summary>
            Create a new <see cref="T:Lucene.Net.Facet.DrillSideways"/> instance, where some
            dimensions were indexed with <see cref="T:Lucene.Net.Facet.SortedSet.SortedSetDocValuesFacetField"/>
            and others were indexed with <see cref="T:Lucene.Net.Facet.FacetField"/>. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.DrillSideways.BuildFacetsResult(Lucene.Net.Facet.FacetsCollector,Lucene.Net.Facet.FacetsCollector[],System.String[])">
            <summary>
            Subclass can override to customize per-dim Facets
            impl. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.DrillSideways.Search(Lucene.Net.Facet.DrillDownQuery,Lucene.Net.Search.ICollector)">
            <summary>
            Search, collecting hits with a <see cref="T:Lucene.Net.Search.ICollector"/>, and
            computing drill down and sideways counts.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.DrillSideways.Search(Lucene.Net.Facet.DrillDownQuery,Lucene.Net.Search.Filter,Lucene.Net.Search.FieldDoc,System.Int32,Lucene.Net.Search.Sort,System.Boolean,System.Boolean)">
            <summary>
            Search, sorting by <see cref="T:Lucene.Net.Search.Sort"/>, and computing
            drill down and sideways counts.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.DrillSideways.Search(Lucene.Net.Facet.DrillDownQuery,System.Int32)">
            <summary>
            Search, sorting by score, and computing
            drill down and sideways counts.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.DrillSideways.Search(Lucene.Net.Search.ScoreDoc,Lucene.Net.Facet.DrillDownQuery,System.Int32)">
            <summary>
            Search, sorting by score, and computing
            drill down and sideways counts.
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.DrillSideways.ScoreSubDocsAtOnce">
            <summary>
            Override this and return true if your collector
            (e.g., <see cref="T:Lucene.Net.Join.ToParentBlockJoinCollector"/>) expects all
            sub-scorers to be positioned on the document being
            collected.  This will cause some performance loss;
            default is <c>false</c>.  Note that if you return true from
            this method (in a subclass) be sure your collector
            also returns <c>false</c> from <see cref="P:Lucene.Net.Search.ICollector.AcceptsDocsOutOfOrder"/>: 
            this will trick <see cref="T:Lucene.Net.Search.BooleanQuery"/> into also scoring all subDocs at
            once. 
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.DrillSidewaysResult">
            <summary>
            Result of a drill sideways search, including the
            <see cref="T:Lucene.Net.Facet.Facets"/> and <see cref="T:Lucene.Net.Search.TopDocs"/>. 
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.DrillSidewaysResult.Facets">
            <summary>
            Combined drill down &amp; sideways results.
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.DrillSidewaysResult.Hits">
            <summary>
            Hits.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.DrillSidewaysResult.#ctor(Lucene.Net.Facet.Facets,Lucene.Net.Search.TopDocs)">
            <summary>
            Sole constructor.
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.DrillSidewaysQuery">
            <summary>
            Only purpose is to punch through and return a
            <see cref="T:Lucene.Net.Facet.DrillSidewaysScorer"/> 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.DrillSidewaysScorer.DoQueryFirstScoring(Lucene.Net.Search.ICollector,Lucene.Net.Search.DocIdSetIterator[],Lucene.Net.Search.ICollector[],Lucene.Net.Util.IBits[],Lucene.Net.Search.ICollector[])">
            <summary>
            Used when base query is highly constraining vs the
            drilldowns, or when the docs must be scored at once
            (i.e., like <see cref="T:Lucene.Net.Search.BooleanScorer2"/>, not <see cref="T:Lucene.Net.Search.BooleanScorer"/>).  In
            this case we just .Next() on base and .Advance() on
            the dim filters.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.DrillSidewaysScorer.DoDrillDownAdvanceScoring(Lucene.Net.Search.ICollector,Lucene.Net.Search.DocIdSetIterator[],Lucene.Net.Search.ICollector[])">
            <summary>
            Used when drill downs are highly constraining vs
            baseQuery.
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.FacetField">
            <summary>
            Add an instance of this to your <see cref="T:Lucene.Net.Documents.Document"/> for every facet label.
            
            <para>
            <b>NOTE:</b> you must call <see cref="M:Lucene.Net.Facet.FacetsConfig.Build(Lucene.Net.Documents.Document)"/> before
            you add the document to <see cref="T:Lucene.Net.Index.IndexWriter"/>.
            </para>
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.FacetField.Dim">
            <summary>
            Dimension for this field.
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.FacetField.Path">
            <summary>
            Path for this field.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.FacetField.#ctor(System.String,System.String[])">
            <summary>
            Creates the this from <paramref name="dim"/> and
            <paramref name="path"/>. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.FacetField.VerifyLabel(System.String)">
            <summary>
            Verifies the label is not null or empty string.
            
             @lucene.internal 
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.FacetResult">
            <summary>
            Counts or aggregates for a single dimension.
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.FacetResult.Dim">
            <summary>
            Dimension that was requested.
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.FacetResult.Path">
            <summary>
            Path whose children were requested.
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.FacetResult.Value">
            <summary>
            Total value for this path (sum of all child counts, or
            sum of all child values), even those not included in
            the topN. 
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.FacetResult.ChildCount">
            <summary>
            How many child labels were encountered.
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.FacetResult.LabelValues">
            <summary>
            Child counts.
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.FacetResult.TypeOfValue">
            <summary>
            The original data type of <see cref="P:Lucene.Net.Facet.FacetResult.Value"/> that was passed through the constructor.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.FacetResult.#ctor(System.String,System.String[],System.Single,Lucene.Net.Facet.LabelAndValue[],System.Int32)">
            <summary>
            Constructor for <see cref="T:System.Single"/> <paramref name="value"/>. Makes the <see cref="M:Lucene.Net.Facet.FacetResult.ToString"/> method 
            print the <paramref name="value"/> as a <see cref="T:System.Single"/> with at least 1 number after the decimal.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.FacetResult.#ctor(System.String,System.String[],System.Int32,Lucene.Net.Facet.LabelAndValue[],System.Int32)">
            <summary>
            Constructor for <see cref="T:System.Int32"/> <paramref name="value"/>. Makes the <see cref="M:Lucene.Net.Facet.FacetResult.ToString"/> method 
            print the <paramref name="value"/> as an <see cref="T:System.Int32"/> with no decimal.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.FacetResult.ToString">
            <summary>
            Converts the value of this instance to its equivalent string representation.
            </summary>
            <returns>A string representation of the values of <see cref="T:Lucene.Net.Facet.FacetResult"/>.</returns>
        </member>
        <member name="M:Lucene.Net.Facet.FacetResult.ToString(System.IFormatProvider)">
            <summary>
            Converts the value of this instance to its equivalent string representation
            using the specified culture-specific format information.
            </summary>
            <param name="provider">An object that supplies culture-specific formatting information.</param>
            <returns>A string representation of the values of <see cref="T:Lucene.Net.Facet.FacetResult"/>
            as specified by <paramref name="provider"/>.</returns>
        </member>
        <member name="T:Lucene.Net.Facet.Facets">
            <summary>
            Common base class for all facets implementations.
            
            @lucene.experimental 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Facets.#ctor">
            <summary>
            Default constructor.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Facets.GetTopChildren(System.Int32,System.String,System.String[])">
            <summary>
            Returns the topN child labels under the specified
            path.  Returns null if the specified path doesn't
            exist or if this dimension was never seen. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Facets.GetSpecificValue(System.String,System.String[])">
            <summary>
            Return the count or value
            for a specific path.  Returns -1 if
            this path doesn't exist, else the count. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Facets.GetAllDims(System.Int32)">
            <summary>
            Returns topN labels for any dimension that had hits,
            sorted by the number of hits that dimension matched;
            this is used for "sparse" faceting, where many
            different dimensions were indexed, for example
            depending on the type of document. 
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.FacetsCollector">
            <summary>
            Collects hits for subsequent faceting.  Once you've run
            a search and collect hits into this, instantiate one of
            the <see cref="T:Lucene.Net.Search.ICollector"/> subclasses to do the facet
            counting.  Use the Search utility methods (such as <see cref="M:Lucene.Net.Facet.FacetsCollector.Search(Lucene.Net.Search.IndexSearcher,Lucene.Net.Search.Query,System.Int32,Lucene.Net.Search.ICollector)"/>) to
            perform an "ordinary" search but also collect into a
            <see cref="T:Lucene.Net.Facet.Facets"/>. 
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.FacetsCollector.Docs">
            <summary>
            Used during collection to record matching docs and then return a
            <see cref="P:Lucene.Net.Facet.FacetsCollector.Docs.DocIdSet"/> that contains them.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.FacetsCollector.Docs.#ctor">
            <summary>
            Sole constructor.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.FacetsCollector.Docs.AddDoc(System.Int32)">
            <summary>
            Record the given document.
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.FacetsCollector.Docs.DocIdSet">
            <summary>
            Return the <see cref="P:Lucene.Net.Facet.FacetsCollector.Docs.DocIdSet"/> which contains all the recorded docs.
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.FacetsCollector.MatchingDocs">
            <summary>
            Holds the documents that were matched in the <see cref="T:Lucene.Net.Index.AtomicReaderContext"/>.
            If scores were required, then <see cref="P:Lucene.Net.Facet.FacetsCollector.MatchingDocs.Scores"/> is not <c>null</c>.
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.FacetsCollector.MatchingDocs.Context">
            <summary>
            Context for this segment. </summary>
        </member>
        <member name="P:Lucene.Net.Facet.FacetsCollector.MatchingDocs.Bits">
            <summary>
            Which documents were seen. </summary>
        </member>
        <member name="P:Lucene.Net.Facet.FacetsCollector.MatchingDocs.Scores">
            <summary>
            Non-sparse scores array. </summary>
        </member>
        <member name="P:Lucene.Net.Facet.FacetsCollector.MatchingDocs.TotalHits">
            <summary>
            Total number of hits </summary>
        </member>
        <member name="M:Lucene.Net.Facet.FacetsCollector.MatchingDocs.#ctor(Lucene.Net.Index.AtomicReaderContext,Lucene.Net.Search.DocIdSet,System.Int32,System.Single[])">
            <summary>
            Sole constructor.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.FacetsCollector.#ctor">
            <summary>
            Default constructor
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.FacetsCollector.#ctor(System.Boolean)">
            <summary>
            Create this; if <paramref name="keepScores"/> is <c>true</c> then a
            <see cref="T:float[]"/> is allocated to hold score of all hits. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.FacetsCollector.CreateDocs(System.Int32)">
            <summary>
            Creates a <see cref="T:Lucene.Net.Facet.FacetsCollector.Docs"/> to record hits. The default uses <see cref="T:Lucene.Net.Util.FixedBitSet"/>
            to record hits and you can override to e.g. record the docs in your own
            <see cref="T:Lucene.Net.Search.DocIdSet"/>.
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.FacetsCollector.KeepScores">
            <summary>
            True if scores were saved.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.FacetsCollector.GetMatchingDocs">
            <summary>
            Returns the documents matched by the query, one <see cref="T:Lucene.Net.Facet.FacetsCollector.MatchingDocs"/> per
            visited segment.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.FacetsCollector.Search(Lucene.Net.Search.IndexSearcher,Lucene.Net.Search.Query,System.Int32,Lucene.Net.Search.ICollector)">
            <summary>
            Utility method, to search and also collect all hits
            into the provided <see cref="T:Lucene.Net.Search.ICollector"/>. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.FacetsCollector.Search(Lucene.Net.Search.IndexSearcher,Lucene.Net.Search.Query,Lucene.Net.Search.Filter,System.Int32,Lucene.Net.Search.ICollector)">
            <summary>
            Utility method, to search and also collect all hits
            into the provided <see cref="T:Lucene.Net.Search.ICollector"/>. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.FacetsCollector.Search(Lucene.Net.Search.IndexSearcher,Lucene.Net.Search.Query,Lucene.Net.Search.Filter,System.Int32,Lucene.Net.Search.Sort,Lucene.Net.Search.ICollector)">
            <summary>
            Utility method, to search and also collect all hits
            into the provided <see cref="T:Lucene.Net.Search.ICollector"/>. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.FacetsCollector.Search(Lucene.Net.Search.IndexSearcher,Lucene.Net.Search.Query,Lucene.Net.Search.Filter,System.Int32,Lucene.Net.Search.Sort,System.Boolean,System.Boolean,Lucene.Net.Search.ICollector)">
            <summary>
            Utility method, to search and also collect all hits
            into the provided <see cref="T:Lucene.Net.Search.ICollector"/>. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.FacetsCollector.SearchAfter(Lucene.Net.Search.IndexSearcher,Lucene.Net.Search.ScoreDoc,Lucene.Net.Search.Query,System.Int32,Lucene.Net.Search.ICollector)">
            <summary>
            Utility method, to search and also collect all hits
            into the provided <see cref="T:Lucene.Net.Search.ICollector"/>. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.FacetsCollector.SearchAfter(Lucene.Net.Search.IndexSearcher,Lucene.Net.Search.ScoreDoc,Lucene.Net.Search.Query,Lucene.Net.Search.Filter,System.Int32,Lucene.Net.Search.ICollector)">
            <summary>
            Utility method, to search and also collect all hits
            into the provided <see cref="T:Lucene.Net.Search.ICollector"/>. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.FacetsCollector.SearchAfter(Lucene.Net.Search.IndexSearcher,Lucene.Net.Search.ScoreDoc,Lucene.Net.Search.Query,Lucene.Net.Search.Filter,System.Int32,Lucene.Net.Search.Sort,Lucene.Net.Search.ICollector)">
            <summary>
            Utility method, to search and also collect all hits
            into the provided <see cref="T:Lucene.Net.Search.ICollector"/>. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.FacetsCollector.SearchAfter(Lucene.Net.Search.IndexSearcher,Lucene.Net.Search.ScoreDoc,Lucene.Net.Search.Query,Lucene.Net.Search.Filter,System.Int32,Lucene.Net.Search.Sort,System.Boolean,System.Boolean,Lucene.Net.Search.ICollector)">
            <summary>
            Utility method, to search and also collect all hits
            into the provided <see cref="T:Lucene.Net.Search.ICollector"/>. 
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.FacetsConfig">
             <summary>
             Records per-dimension configuration.  By default a
             dimension is flat, single valued and does
             not require count for the dimension; use
             the setters in this class to change these settings for
             each dim.
            
             <para>
             <b>NOTE</b>: this configuration is not saved into the
             index, but it's vital, and up to the application to
             ensure, that at search time the provided <see cref="T:Lucene.Net.Facet.FacetsConfig"/>
             matches what was used during indexing.
            
              @lucene.experimental
             </para>
             </summary>
        </member>
        <member name="F:Lucene.Net.Facet.FacetsConfig.DEFAULT_INDEX_FIELD_NAME">
            <summary>
            Which Lucene field holds the drill-downs and ords (as
            doc values).
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.FacetsConfig.DimConfig">
             <summary>
             Holds the configuration for one dimension
            
             @lucene.experimental
             </summary>
        </member>
        <member name="P:Lucene.Net.Facet.FacetsConfig.DimConfig.IsHierarchical">
            <summary>
            True if this dimension is hierarchical. </summary>
        </member>
        <member name="P:Lucene.Net.Facet.FacetsConfig.DimConfig.IsMultiValued">
            <summary>
            True if this dimension is multi-valued. </summary>
        </member>
        <member name="P:Lucene.Net.Facet.FacetsConfig.DimConfig.RequireDimCount">
            <summary>
            True if the count/aggregate for the entire dimension
             is required, which is unusual (default is false).
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.FacetsConfig.DimConfig.IndexFieldName">
            <summary>
            Actual field where this dimension's facet labels
             should be indexed
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.FacetsConfig.DimConfig.#ctor">
            <summary>
            Default constructor.
            </summary>
        </member>
        <member name="F:Lucene.Net.Facet.FacetsConfig.DEFAULT_DIM_CONFIG">
            <summary>
            Default per-dimension configuration. </summary>
        </member>
        <member name="M:Lucene.Net.Facet.FacetsConfig.#ctor">
            <summary>
            Default constructor.
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.FacetsConfig.DefaultDimConfig">
            <summary>
            Get the default configuration for new dimensions.  Useful when
            the dimension is not known beforehand and may need different
            global default settings, like <c>multivalue = true</c>.
            </summary>
            <returns>
            The default configuration to be used for dimensions that
            are not yet set in the <see cref="T:Lucene.Net.Facet.FacetsConfig"/>
            </returns>
        </member>
        <member name="M:Lucene.Net.Facet.FacetsConfig.GetDimConfig(System.String)">
            <summary>
            Get the current configuration for a dimension.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.FacetsConfig.SetHierarchical(System.String,System.Boolean)">
            <summary>
            Pass <c>true</c> if this dimension is hierarchical
            (has depth > 1 paths).
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.FacetsConfig.SetMultiValued(System.String,System.Boolean)">
            <summary>
            Pass <c>true</c> if this dimension may have more than
            one value per document.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.FacetsConfig.SetRequireDimCount(System.String,System.Boolean)">
            <summary>
            Pass <c>true</c> if at search time you require
            accurate counts of the dimension, i.e. how many
            hits have this dimension.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.FacetsConfig.SetIndexFieldName(System.String,System.String)">
            <summary>
            Specify which index field name should hold the
            ordinals for this dimension; this is only used by the
            taxonomy based facet methods.
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.FacetsConfig.DimConfigs">
            <summary>
            Returns map of field name to <see cref="T:Lucene.Net.Facet.FacetsConfig.DimConfig"/>.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.FacetsConfig.Build(Lucene.Net.Documents.Document)">
             <summary>
             Translates any added <see cref="T:Lucene.Net.Facet.FacetField"/>s into normal fields for indexing;
             only use this version if you did not add any taxonomy-based fields
             (<see cref="T:Lucene.Net.Facet.FacetField"/> or <see cref="T:Lucene.Net.Facet.Taxonomy.AssociationFacetField"/>).
            
             <para>
             <b>NOTE:</b> you should add the returned document to <see cref="T:Lucene.Net.Index.IndexWriter"/>, not the
             input one!
             </para>
             </summary>
        </member>
        <member name="M:Lucene.Net.Facet.FacetsConfig.Build(Lucene.Net.Facet.Taxonomy.ITaxonomyWriter,Lucene.Net.Documents.Document)">
             <summary>
             Translates any added <see cref="T:Lucene.Net.Facet.FacetField"/>s into normal fields for indexing.
            
             <para>
             <b>NOTE:</b> you should add the returned document to <see cref="T:Lucene.Net.Index.IndexWriter"/>, not the
             input one!
             </para>
             </summary>
        </member>
        <member name="M:Lucene.Net.Facet.FacetsConfig.DedupAndEncode(Lucene.Net.Util.Int32sRef)">
            <summary>
            Encodes ordinals into a <see cref="T:Lucene.Net.Util.BytesRef"/>; expert: subclass can
            override this to change encoding.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.FacetsConfig.PathToString(System.String,System.String[])">
            <summary>
            Turns a dim + path into an encoded string.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.FacetsConfig.PathToString(System.String[])">
            <summary>
            Turns a dim + path into an encoded string.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.FacetsConfig.PathToString(System.String[],System.Int32)">
            <summary>
            Turns the first <paramref name="length"/> elements of <paramref name="path"/>
            into an encoded string.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.FacetsConfig.StringToPath(System.String)">
            <summary>
            Turns an encoded string (from a previous call to <see cref="M:Lucene.Net.Facet.FacetsConfig.PathToString(System.String[])"/>)
            back into the original <see cref="T:string[]"/>.
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.LabelAndValue">
            <summary>
            Single label and its value, usually contained in a
            <see cref="T:Lucene.Net.Facet.FacetResult"/>. 
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.LabelAndValue.Label">
            <summary>
            Facet's label. </summary>
        </member>
        <member name="P:Lucene.Net.Facet.LabelAndValue.Value">
            <summary>
            Value associated with this label. </summary>
        </member>
        <member name="P:Lucene.Net.Facet.LabelAndValue.TypeOfValue">
            <summary>
            The original data type of <see cref="P:Lucene.Net.Facet.LabelAndValue.Value"/> that was passed through the constructor.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.LabelAndValue.#ctor(System.String,System.Single)">
            <summary>
            Constructor for <see cref="T:System.Single"/> <paramref name="value"/>. Makes the <see cref="M:Lucene.Net.Facet.LabelAndValue.ToString"/> method 
            print the <paramref name="value"/> as a <see cref="T:System.Single"/> with at least 1 number after the decimal.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.LabelAndValue.#ctor(System.String,System.Int32)">
            <summary>
            Constructor for <see cref="T:System.Int32"/> <paramref name="value"/>. Makes the <see cref="M:Lucene.Net.Facet.LabelAndValue.ToString"/> method 
            print the <paramref name="value"/> as an <see cref="T:System.Int32"/> with no decimal.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.LabelAndValue.ToString">
            <summary>
            Converts the value of this instance to its equivalent string representation.
            </summary>
            <returns>The string representation of the label and value of this instance.</returns>
        </member>
        <member name="M:Lucene.Net.Facet.LabelAndValue.ToString(System.IFormatProvider)">
            <summary>
            Converts the value of this instance to its equivalent string representation
            using the specified culture-specific format information.
            </summary>
            <returns>The string representation of the label and value of this instance
            as specified by <paramref name="provider"/>.</returns>
        </member>
        <member name="T:Lucene.Net.Facet.MultiFacets">
            <summary>
            Maps specified dims to provided <see cref="T:Lucene.Net.Facet.Facets"/> impls; else, uses
            the default <see cref="T:Lucene.Net.Facet.Facets"/> impl. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.MultiFacets.#ctor(System.Collections.Generic.IDictionary{System.String,Lucene.Net.Facet.Facets},Lucene.Net.Facet.Facets)">
            <summary>
            Create this, with the specified default <see cref="T:Lucene.Net.Facet.Facets"/>
            for fields not included in <paramref name="dimToFacets"/>. 
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.RandomSamplingFacetsCollector">
            <summary>
            Collects hits for subsequent faceting, using sampling if needed. Once you've
            run a search and collect hits into this, instantiate one of the
            <see cref="T:Lucene.Net.Facet.Facets"/> subclasses to do the facet counting. Note that this collector
            does not collect the scores of matching docs (i.e.
            <see cref="P:Lucene.Net.Facet.FacetsCollector.MatchingDocs.Scores"/>) is <c>null</c>.
            <para>
            If you require the original set of hits, you can call
            <see cref="M:Lucene.Net.Facet.RandomSamplingFacetsCollector.GetOriginalMatchingDocs"/>. Also, since the counts of the top-facets
            is based on the sampled set, you can amortize the counts by calling
            <see cref="M:Lucene.Net.Facet.RandomSamplingFacetsCollector.AmortizeFacetCounts(Lucene.Net.Facet.FacetResult,Lucene.Net.Facet.FacetsConfig,Lucene.Net.Search.IndexSearcher)"/>.
            </para>
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.RandomSamplingFacetsCollector.XORShift64Random">
            <summary>
            Faster alternative for java.util.Random, inspired by
            http://dmurphy747.wordpress.com/2011/03/23/xorshift-vs-random-performance-in-java/
            <para>
            Has a period of 2^64-1
            </para>
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.RandomSamplingFacetsCollector.XORShift64Random.#ctor(System.Int64)">
            <summary>
            Creates a xorshift random generator using the provided seed
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.RandomSamplingFacetsCollector.XORShift64Random.RandomInt64">
            <summary>
            Get the next random long value
            <para/>
            NOTE: This was randomLong() in Lucene
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.RandomSamplingFacetsCollector.XORShift64Random.NextInt32(System.Int32)">
            <summary>
            Get the next random int, between 0 (inclusive) and <paramref name="n"/> (exclusive)
            <para/>
            NOTE: This was nextInt() in Lucene
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.RandomSamplingFacetsCollector.#ctor(System.Int32)">
            <summary>
            Constructor with the given sample size and default seed.
            </summary>
            <seealso cref="M:Lucene.Net.Facet.RandomSamplingFacetsCollector.#ctor(System.Int32,System.Int64)"/>
        </member>
        <member name="M:Lucene.Net.Facet.RandomSamplingFacetsCollector.#ctor(System.Int32,System.Int64)">
            <summary>
            Constructor with the given sample size and seed.
            </summary>
            <param name="sampleSize">
                     The preferred sample size. If the number of hits is greater than
                     the size, sampling will be done using a sample ratio of sampling
                     size / totalN. For example: 1000 hits, sample size = 10 results in
                     samplingRatio of 0.01. If the number of hits is lower, no sampling
                     is done at all </param>
            <param name="seed">
                     The random seed. If <c>0</c> then a seed will be chosen for you. </param>
        </member>
        <member name="M:Lucene.Net.Facet.RandomSamplingFacetsCollector.GetMatchingDocs">
            <summary>
            Returns the sampled list of the matching documents. Note that a
            <see cref="T:Lucene.Net.Facet.FacetsCollector.MatchingDocs"/> instance is returned per segment, even
            if no hits from that segment are included in the sampled set.
            <para>
            Note: One or more of the <see cref="T:Lucene.Net.Facet.FacetsCollector.MatchingDocs"/> might be empty (not containing any
            hits) as result of sampling.
            </para>
            <para>
            Note: <see cref="P:Lucene.Net.Facet.FacetsCollector.MatchingDocs.TotalHits"/> is copied from the original
            <see cref="T:Lucene.Net.Facet.FacetsCollector.MatchingDocs"/>, scores is set to <c>null</c>
            </para>
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.RandomSamplingFacetsCollector.GetOriginalMatchingDocs">
            <summary>
            Returns the original matching documents.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.RandomSamplingFacetsCollector.CreateSampledDocs(System.Collections.Generic.ICollection{Lucene.Net.Facet.FacetsCollector.MatchingDocs})">
            <summary>
            Create a sampled copy of the matching documents list.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.RandomSamplingFacetsCollector.CreateSample(Lucene.Net.Facet.FacetsCollector.MatchingDocs)">
            <summary>
            Create a sampled of the given hits.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.RandomSamplingFacetsCollector.AmortizeFacetCounts(Lucene.Net.Facet.FacetResult,Lucene.Net.Facet.FacetsConfig,Lucene.Net.Search.IndexSearcher)">
            <summary>
            Note: if you use a counting <see cref="T:Lucene.Net.Facet.Facets"/> implementation, you can amortize the
            sampled counts by calling this method. Uses the <see cref="T:Lucene.Net.Facet.FacetsConfig"/> and
            the <see cref="T:Lucene.Net.Search.IndexSearcher"/> to determine the upper bound for each facet value.
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.RandomSamplingFacetsCollector.SamplingRate">
            <summary>
            Returns the sampling rate that was used.
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.Range.DoubleRange">
            <summary>
            Represents a range over double values.
            
            @lucene.experimental 
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.Range.DoubleRange.Min">
            <summary>
            Minimum. </summary>
        </member>
        <member name="P:Lucene.Net.Facet.Range.DoubleRange.Max">
            <summary>
            Maximum. </summary>
        </member>
        <member name="P:Lucene.Net.Facet.Range.DoubleRange.MinInclusive">
            <summary>
            True if the minimum value is inclusive. </summary>
        </member>
        <member name="P:Lucene.Net.Facet.Range.DoubleRange.MaxInclusive">
            <summary>
            True if the maximum value is inclusive. </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Range.DoubleRange.#ctor(System.String,System.Double,System.Boolean,System.Double,System.Boolean)">
            <summary>
            Create a DoubleRange. </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Range.DoubleRange.Accept(System.Double)">
            <summary>
            True if this range accepts the provided value. </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Range.DoubleRange.ToInt64Range">
            <summary>
            NOTE: This was toLongRange() in Lucene
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.Range.DoubleRangeFacetCounts">
            <summary>
            <see cref="T:Lucene.Net.Facet.Facets"/> implementation that computes counts for
             dynamic double ranges from a provided <see cref="T:Lucene.Net.Queries.Function.ValueSource"/>, 
             using <see cref="M:Lucene.Net.Queries.Function.FunctionValues.DoubleVal(System.Int32)"/> or <see cref="M:Lucene.Net.Queries.Function.FunctionValues.DoubleVal(System.Int32,System.Double[])"/>.  Use
             this for dimensions that change in real-time (e.g. a
             relative time based dimension like "Past day", "Past 2
             days", etc.) or that change for each request (e.g.
             distance from the user's location, "&lt; 1 km", "&lt; 2 km",
             etc.).
            
             <para> If you had indexed your field using <see cref="T:Lucene.Net.Documents.SingleDocValuesField"/> 
             then pass <see cref="T:Lucene.Net.Queries.Function.ValueSources.SingleFieldSource"/>
             as the <see cref="T:Lucene.Net.Queries.Function.ValueSource"/>; if you used 
             <see cref="T:Lucene.Net.Documents.DoubleDocValuesField"/> then pass 
             <see cref="T:Lucene.Net.Queries.Function.ValueSources.DoubleFieldSource"/> (this is the default used when you
             pass just a the field name).
            
            @lucene.experimental 
            </para>
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Range.DoubleRangeFacetCounts.#ctor(System.String,Lucene.Net.Facet.FacetsCollector,Lucene.Net.Facet.Range.DoubleRange[])">
            <summary>
            Create <see cref="T:Lucene.Net.Facet.Range.RangeFacetCounts"/>, using 
            <see cref="T:Lucene.Net.Queries.Function.ValueSources.DoubleFieldSource"/> from the specified field. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Range.DoubleRangeFacetCounts.#ctor(System.String,Lucene.Net.Queries.Function.ValueSource,Lucene.Net.Facet.FacetsCollector,Lucene.Net.Facet.Range.DoubleRange[])">
            <summary>
            Create <see cref="T:Lucene.Net.Facet.Range.RangeFacetCounts"/>, using the provided
            <see cref="T:Lucene.Net.Queries.Function.ValueSource"/>. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Range.DoubleRangeFacetCounts.#ctor(System.String,Lucene.Net.Queries.Function.ValueSource,Lucene.Net.Facet.FacetsCollector,Lucene.Net.Search.Filter,Lucene.Net.Facet.Range.DoubleRange[])">
            <summary>
            Create <see cref="T:Lucene.Net.Facet.Range.RangeFacetCounts"/>, using the provided
            <see cref="T:Lucene.Net.Queries.Function.ValueSource"/>, and using the provided Filter as
            a fastmatch: only documents passing the filter are
            checked for the matching ranges.  The filter must be
            random access (implement <see cref="P:Lucene.Net.Search.DocIdSet.Bits"/>). 
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.Range.Int64Range">
            <summary>
            Represents a range over <see cref="T:System.Int64"/> values.
            <para/>
            NOTE: This was LongRange in Lucene
            
            @lucene.experimental 
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.Range.Int64Range.Min">
            <summary>
            Minimum. </summary>
        </member>
        <member name="P:Lucene.Net.Facet.Range.Int64Range.Max">
            <summary>
            Maximum. </summary>
        </member>
        <member name="P:Lucene.Net.Facet.Range.Int64Range.MinInclusive">
            <summary>
            True if the minimum value is inclusive. </summary>
        </member>
        <member name="P:Lucene.Net.Facet.Range.Int64Range.MaxInclusive">
            <summary>
            True if the maximum value is inclusive. </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Range.Int64Range.#ctor(System.String,System.Int64,System.Boolean,System.Int64,System.Boolean)">
            <summary>
            Create a <see cref="T:Lucene.Net.Facet.Range.Int64Range"/>. </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Range.Int64Range.Accept(System.Int64)">
            <summary>
            True if this range accepts the provided value. </summary>
        </member>
        <member name="T:Lucene.Net.Facet.Range.Int64RangeCounter">
            <summary>
            Counts how many times each range was seen;
            per-hit it's just a binary search (<see cref="M:Lucene.Net.Facet.Range.Int64RangeCounter.Add(System.Int64)"/>)
            against the elementary intervals, and in the end we
            rollup back to the original ranges.
            <para/>
            NOTE: This was LongRangeCounter in Lucene
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Range.Int64RangeCounter.FillCounts(System.Int32[])">
            <summary>
            Fills counts corresponding to the original input
            ranges, returning the missing count (how many hits
            didn't match any ranges). 
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.Range.Int64RangeCounter.Int64RangeNode">
            <summary>
            Holds one node of the segment tree.
            <para/>
            NOTE: This was LongRangeNode in Lucene
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Range.Int64RangeCounter.Int64RangeNode.AddOutputs(System.Int32,Lucene.Net.Facet.Range.Int64Range)">
            <summary>
            Recursively assigns range outputs to each node.
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.Range.Int64RangeFacetCounts">
            <summary>
            <see cref="T:Lucene.Net.Facet.Facets"/> implementation that computes counts for
            dynamic long ranges from a provided <see cref="T:Lucene.Net.Queries.Function.ValueSource"/>,
            using <see cref="M:Lucene.Net.Queries.Function.FunctionValues.Int64Val(System.Int32)"/> or <see cref="M:Lucene.Net.Queries.Function.FunctionValues.Int64Val(System.Int32,System.Int64[])"/>.  Use
            this for dimensions that change in real-time (e.g. a
            relative time based dimension like "Past day", "Past 2
            days", etc.) or that change for each request (e.g. 
            distance from the user's location, "&lt; 1 km", "&lt; 2 km",
            etc.).
            <para/>
            NOTE: This was LongRangeFacetCounts in Lucene
            
            @lucene.experimental 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Range.Int64RangeFacetCounts.#ctor(System.String,Lucene.Net.Facet.FacetsCollector,Lucene.Net.Facet.Range.Int64Range[])">
            <summary>
            Create <see cref="T:Lucene.Net.Facet.Range.Int64RangeFacetCounts"/>, using
            <see cref="T:Lucene.Net.Queries.Function.ValueSources.Int64FieldSource"/> from the specified field. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Range.Int64RangeFacetCounts.#ctor(System.String,Lucene.Net.Queries.Function.ValueSource,Lucene.Net.Facet.FacetsCollector,Lucene.Net.Facet.Range.Int64Range[])">
            <summary>
            Create <see cref="T:Lucene.Net.Facet.Range.Int64RangeFacetCounts"/>, using the provided
            <see cref="T:Lucene.Net.Queries.Function.ValueSource"/>. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Range.Int64RangeFacetCounts.#ctor(System.String,Lucene.Net.Queries.Function.ValueSource,Lucene.Net.Facet.FacetsCollector,Lucene.Net.Search.Filter,Lucene.Net.Facet.Range.Int64Range[])">
            <summary>
            Create <see cref="T:Lucene.Net.Facet.Range.Int64RangeFacetCounts"/>, using the provided
            <see cref="T:Lucene.Net.Queries.Function.ValueSource"/>, and using the provided Filter as
            a fastmatch: only documents passing the filter are
            checked for the matching ranges.  The filter must be
            random access (implement <see cref="P:Lucene.Net.Search.DocIdSet.Bits"/>). 
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.Range.Range">
            <summary>
            Base class for a single labeled range.
            
            @lucene.experimental 
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.Range.Range.Label">
            <summary>
            Label that identifies this range. </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Range.Range.#ctor(System.String)">
            <summary>
            Sole constructor. </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Range.Range.GetFilter(Lucene.Net.Search.Filter,Lucene.Net.Queries.Function.ValueSource)">
            <summary>
            Returns a new <see cref="T:Lucene.Net.Search.Filter"/> accepting only documents
            in this range.  This filter is not general-purpose;
            you should either use it with <see cref="T:Lucene.Net.Facet.DrillSideways"/> by
            adding it to <see cref="M:Lucene.Net.Facet.DrillDownQuery.Add(System.String,Lucene.Net.Search.Filter)"/>, or pass it to
            <see cref="T:Lucene.Net.Search.FilteredQuery"/> using its 
            <see cref="F:Lucene.Net.Search.FilteredQuery.QUERY_FIRST_FILTER_STRATEGY"/>.
            If the <see cref="T:Lucene.Net.Queries.Function.ValueSource"/> is static, e.g. an indexed numeric
            field, then it may be more efficient to use 
            <see cref="T:Lucene.Net.Search.NumericRangeFilter"/>.  The provided <paramref name="fastMatchFilter"/>,
            if non-null, will first be consulted, and only if
            that is set for each document will the range then be
            checked. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Range.Range.GetFilter(Lucene.Net.Queries.Function.ValueSource)">
            <summary>
            Returns a new <see cref="T:Lucene.Net.Search.Filter"/> accepting only documents
             in this range.  This filter is not general-purpose;
             you should either use it with <see cref="T:Lucene.Net.Facet.DrillSideways"/> by
             adding it to <see cref="M:Lucene.Net.Facet.DrillDownQuery.Add(System.String,Lucene.Net.Search.Filter)"/>, or pass it to
             <see cref="T:Lucene.Net.Search.FilteredQuery"/> using its 
             <see cref="F:Lucene.Net.Search.FilteredQuery.QUERY_FIRST_FILTER_STRATEGY"/>.  If the
             <see cref="T:Lucene.Net.Queries.Function.ValueSource"/> is static, e.g. an indexed numeric
             field, then it may be more efficient to use <see cref="T:Lucene.Net.Search.NumericRangeFilter"/>. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Range.Range.FailNoMatch">
            <summary>
            Invoke this for a useless range.
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.Range.RangeFacetCounts">
            <summary>
            Base class for range faceting.
            
            @lucene.experimental 
            </summary>
        </member>
        <member name="F:Lucene.Net.Facet.Range.RangeFacetCounts.m_ranges">
            <summary>
            Ranges passed to constructor. </summary>
        </member>
        <member name="F:Lucene.Net.Facet.Range.RangeFacetCounts.m_counts">
            <summary>
            Counts, initialized in by subclass. </summary>
        </member>
        <member name="F:Lucene.Net.Facet.Range.RangeFacetCounts.m_fastMatchFilter">
            <summary>
            Optional: if specified, we first test this Filter to
            see whether the document should be checked for
            matching ranges.  If this is null, all documents are
            checked. 
            </summary>
        </member>
        <member name="F:Lucene.Net.Facet.Range.RangeFacetCounts.m_field">
            <summary>
            Our field name. </summary>
        </member>
        <member name="F:Lucene.Net.Facet.Range.RangeFacetCounts.m_totCount">
            <summary>
            Total number of hits. </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Range.RangeFacetCounts.#ctor(System.String,Lucene.Net.Facet.Range.Range[],Lucene.Net.Search.Filter)">
            <summary>
            Create <see cref="T:Lucene.Net.Facet.Range.RangeFacetCounts"/> </summary>
        </member>
        <member name="T:Lucene.Net.Facet.SortedSet.DefaultSortedSetDocValuesReaderState">
            <summary>
            Default implementation of <see cref="T:Lucene.Net.Facet.SortedSet.SortedSetDocValuesFacetCounts"/>
            </summary>
        </member>
        <member name="F:Lucene.Net.Facet.SortedSet.DefaultSortedSetDocValuesReaderState.origReader">
            <summary>
            <see cref="T:Lucene.Net.Index.IndexReader"/> passed to the constructor. </summary>
        </member>
        <member name="M:Lucene.Net.Facet.SortedSet.DefaultSortedSetDocValuesReaderState.#ctor(Lucene.Net.Index.IndexReader,System.String)">
            <summary>
            Creates this, pulling doc values from the specified
            field. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.SortedSet.DefaultSortedSetDocValuesReaderState.GetDocValues">
            <summary>
            Return top-level doc values.
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.SortedSet.DefaultSortedSetDocValuesReaderState.PrefixToOrdRange">
            <summary>
            Returns mapping from prefix to <see cref="T:Lucene.Net.Facet.SortedSet.SortedSetDocValuesReaderState.OrdRange"/>.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.SortedSet.DefaultSortedSetDocValuesReaderState.GetOrdRange(System.String)">
            <summary>
            Returns the <see cref="T:Lucene.Net.Facet.SortedSet.SortedSetDocValuesReaderState.OrdRange"/> for this dimension.
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.SortedSet.DefaultSortedSetDocValuesReaderState.Field">
            <summary>
            Indexed field we are reading.
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.SortedSet.DefaultSortedSetDocValuesReaderState.Count">
            <summary>
            Number of unique labels.
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.SortedSet.SortedSetDocValuesFacetCounts">
             <summary>
             Compute facets counts from previously
             indexed <see cref="T:Lucene.Net.Facet.SortedSet.SortedSetDocValuesFacetField"/>,
             without require a separate taxonomy index.  Faceting is
             a bit slower (~25%), and there is added cost on every
             <see cref="T:Lucene.Net.Index.IndexReader"/> open to create a new
             <see cref="T:Lucene.Net.Facet.SortedSet.SortedSetDocValuesReaderState"/>.  Furthermore, this does
             not support hierarchical facets; only flat (dimension +
             label) facets, but it uses quite a bit less RAM to do
             so.
            
             <para><b>NOTE</b>: this class should be instantiated and
             then used from a single thread, because it holds a
             thread-private instance of <see cref="T:Lucene.Net.Index.SortedSetDocValues"/>.
            
             </para>
             <para><b>NOTE:</b>: tie-break is by unicode sort order
            
             @lucene.experimental
             </para>
             </summary>
        </member>
        <member name="M:Lucene.Net.Facet.SortedSet.SortedSetDocValuesFacetCounts.#ctor(Lucene.Net.Facet.SortedSet.SortedSetDocValuesReaderState,Lucene.Net.Facet.FacetsCollector)">
            <summary>
            Sparse faceting: returns any dimension that had any
            hits, topCount labels per dimension.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.SortedSet.SortedSetDocValuesFacetCounts.Count(System.Collections.Generic.IList{Lucene.Net.Facet.FacetsCollector.MatchingDocs})">
            <summary>
            Does all the "real work" of tallying up the counts. </summary>
        </member>
        <member name="T:Lucene.Net.Facet.SortedSet.SortedSetDocValuesFacetField">
            <summary>
            Add an instance of this to your <see cref="T:Lucene.Net.Documents.Document"/> for every facet
            label to be indexed via <see cref="T:Lucene.Net.Index.SortedSetDocValues"/>. 
            </summary>
        </member>
        <member name="F:Lucene.Net.Facet.SortedSet.SortedSetDocValuesFacetField.TYPE">
            <summary>
            Indexed <see cref="T:Lucene.Net.Documents.FieldType"/>. </summary>
        </member>
        <member name="P:Lucene.Net.Facet.SortedSet.SortedSetDocValuesFacetField.Dim">
            <summary>
            Dimension. </summary>
        </member>
        <member name="P:Lucene.Net.Facet.SortedSet.SortedSetDocValuesFacetField.Label">
            <summary>
            Label. </summary>
        </member>
        <member name="M:Lucene.Net.Facet.SortedSet.SortedSetDocValuesFacetField.#ctor(System.String,System.String)">
            <summary>
            Sole constructor. </summary>
        </member>
        <member name="T:Lucene.Net.Facet.SortedSet.SortedSetDocValuesReaderState">
            <summary>
            Wraps a <see cref="T:Lucene.Net.Index.IndexReader"/> and resolves ords
            using existing <see cref="T:Lucene.Net.Index.SortedSetDocValues"/> APIs without a
            separate taxonomy index.  This only supports flat facets
            (dimension + label), and it makes faceting a bit
            slower, adds some cost at reopen time, but avoids
            managing the separate taxonomy index.  It also requires
            less RAM than the taxonomy index, as it manages the flat
            (2-level) hierarchy more efficiently.  In addition, the
            tie-break during faceting is now meaningful (in label
            sorted order).
            
            <para><b>NOTE</b>: creating an instance of this class is
            somewhat costly, as it computes per-segment ordinal maps,
            so you should create it once and re-use that one instance
            for a given <see cref="T:Lucene.Net.Index.IndexReader"/>. 
            </para>
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.SortedSet.SortedSetDocValuesReaderState.OrdRange">
            <summary>
            Holds start/end range of ords, which maps to one
            dimension (someday we may generalize it to map to
            hierarchies within one dimension). 
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.SortedSet.SortedSetDocValuesReaderState.OrdRange.Start">
            <summary>
            Start of range, inclusive: </summary>
        </member>
        <member name="P:Lucene.Net.Facet.SortedSet.SortedSetDocValuesReaderState.OrdRange.End">
            <summary>
            End of range, inclusive: </summary>
        </member>
        <member name="M:Lucene.Net.Facet.SortedSet.SortedSetDocValuesReaderState.OrdRange.#ctor(System.Int32,System.Int32)">
            <summary>
            Start and end are inclusive. </summary>
        </member>
        <member name="M:Lucene.Net.Facet.SortedSet.SortedSetDocValuesReaderState.#ctor">
            <summary>
            Sole constructor. </summary>
        </member>
        <member name="M:Lucene.Net.Facet.SortedSet.SortedSetDocValuesReaderState.GetDocValues">
            <summary>
            Return top-level doc values. </summary>
        </member>
        <member name="P:Lucene.Net.Facet.SortedSet.SortedSetDocValuesReaderState.Field">
            <summary>
            Indexed field we are reading. </summary>
        </member>
        <member name="M:Lucene.Net.Facet.SortedSet.SortedSetDocValuesReaderState.GetOrdRange(System.String)">
            <summary>
            Returns the <see cref="T:Lucene.Net.Facet.SortedSet.SortedSetDocValuesReaderState.OrdRange"/> for this dimension. </summary>
        </member>
        <member name="P:Lucene.Net.Facet.SortedSet.SortedSetDocValuesReaderState.PrefixToOrdRange">
            <summary>
            Returns mapping from prefix to <see cref="T:Lucene.Net.Facet.SortedSet.SortedSetDocValuesReaderState.OrdRange"/>. </summary>
        </member>
        <member name="P:Lucene.Net.Facet.SortedSet.SortedSetDocValuesReaderState.OrigReader">
            <summary>
            Returns top-level index reader. </summary>
        </member>
        <member name="P:Lucene.Net.Facet.SortedSet.SortedSetDocValuesReaderState.Count">
            <summary>
            Number of unique labels. </summary>
        </member>
        <member name="T:Lucene.Net.Facet.Taxonomy.AssociationFacetField">
            <summary>
            Add an instance of this to your <see cref="T:Lucene.Net.Documents.Document"/> to add
            a facet label associated with an arbitrary <see cref="T:byte[]"/>.
            This will require a custom <see cref="T:Lucene.Net.Facet.Facets"/>
            implementation at search time; see <see cref="T:Lucene.Net.Facet.Taxonomy.Int32AssociationFacetField"/> 
            and <see cref="T:Lucene.Net.Facet.Taxonomy.SingleAssociationFacetField"/> to use existing 
            <see cref="T:Lucene.Net.Facet.Facets"/> implementations.
            <para/>
            @lucene.experimental 
            </summary>
        </member>
        <member name="F:Lucene.Net.Facet.Taxonomy.AssociationFacetField.TYPE">
            <summary>
            Indexed <see cref="T:Lucene.Net.Documents.FieldType"/>.
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.Taxonomy.AssociationFacetField.Dim">
            <summary>
            Dimension for this field.
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.Taxonomy.AssociationFacetField.Path">
            <summary>
            Facet path for this field.
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.Taxonomy.AssociationFacetField.Assoc">
            <summary>
            Associated value.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.AssociationFacetField.#ctor(Lucene.Net.Util.BytesRef,System.String,System.String[])">
            <summary>
            Creates this from <paramref name="dim"/> and <paramref name="path"/> and an
            association 
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.Taxonomy.CachedOrdinalsReader">
            <summary>
            A per-segment cache of documents' facet ordinals. Every
            <see cref="T:Lucene.Net.Facet.Taxonomy.CachedOrdinalsReader.CachedOrds"/> holds the ordinals in a raw <see cref="T:int[]"/>, 
            and therefore consumes as much RAM as the total
            number of ordinals found in the segment, but saves the
            CPU cost of decoding ordinals during facet counting.
            
            <para>
            <b>NOTE:</b> every <see cref="T:Lucene.Net.Facet.Taxonomy.CachedOrdinalsReader.CachedOrds"/> is limited to 2.1B
            total ordinals. If that is a limitation for you then
            consider limiting the segment size to fewer documents, or
            use an alternative cache which pages through the category
            ordinals.
            
            </para>
            <para>
            <b>NOTE:</b> when using this cache, it is advised to use
            a <see cref="T:Lucene.Net.Codecs.DocValuesFormat"/> that does not cache the data in
            memory, at least for the category lists fields, or
            otherwise you'll be doing double-caching.
            
            </para>
            <para>
            <b>NOTE:</b> create one instance of this and re-use it
            for all facet implementations (the cache is per-instance,
            not static).
            </para>
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.CachedOrdinalsReader.#ctor(Lucene.Net.Facet.Taxonomy.OrdinalsReader)">
            <summary>
            Sole constructor. </summary>
        </member>
        <member name="T:Lucene.Net.Facet.Taxonomy.CachedOrdinalsReader.CachedOrds">
            <summary>
            Holds the cached ordinals in two parallel <see cref="T:int[]"/> arrays.
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.Taxonomy.CachedOrdinalsReader.CachedOrds.Offsets">
            <summary>
            Index into <see cref="P:Lucene.Net.Facet.Taxonomy.CachedOrdinalsReader.CachedOrds.Ordinals"/> for each document.
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.Taxonomy.CachedOrdinalsReader.CachedOrds.Ordinals">
            <summary>
            Holds ords for all docs.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.CachedOrdinalsReader.CachedOrds.#ctor(Lucene.Net.Facet.Taxonomy.OrdinalsReader.OrdinalsSegmentReader,System.Int32)">
            <summary>
            Creates a new <see cref="T:Lucene.Net.Facet.Taxonomy.CachedOrdinalsReader.CachedOrds"/> from the <see cref="T:Lucene.Net.Index.BinaryDocValues"/>.
            Assumes that the <see cref="T:Lucene.Net.Index.BinaryDocValues"/> is not <c>null</c>.
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.Taxonomy.CategoryPath">
            <summary>
            Holds a sequence of string components, specifying the hierarchical name of a
            category.
            
            @lucene.experimental
            </summary>
        </member>
        <member name="F:Lucene.Net.Facet.Taxonomy.CategoryPath.EMPTY">
            <summary>
            An empty <see cref="T:Lucene.Net.Facet.Taxonomy.CategoryPath"/>
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.Taxonomy.CategoryPath.Components">
            <summary>
            The components of this <see cref="T:Lucene.Net.Facet.Taxonomy.CategoryPath"/>. Note that this array may be
            shared with other <see cref="T:Lucene.Net.Facet.Taxonomy.CategoryPath"/> instances, e.g. as a result of
            <see cref="M:Lucene.Net.Facet.Taxonomy.CategoryPath.Subpath(System.Int32)"/>, therefore you should traverse the array up to
            <see cref="P:Lucene.Net.Facet.Taxonomy.CategoryPath.Length"/> for this path's components.
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.Taxonomy.CategoryPath.Length">
            <summary>
            The number of components of this <see cref="T:Lucene.Net.Facet.Taxonomy.CategoryPath"/>. </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.CategoryPath.#ctor(System.String[])">
            <summary>
            Construct from the given path <paramref name="components"/>.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.CategoryPath.#ctor(System.String,System.Char)">
            <summary>
            Construct from a given path, separating path components with <paramref name="delimiter"/>.
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.Taxonomy.CategoryPath.FullPathLength">
            <summary>
            Returns the number of characters needed to represent the path, including
            delimiter characters, for using with
            <see cref="M:Lucene.Net.Facet.Taxonomy.CategoryPath.CopyFullPath(System.Char[],System.Int32,System.Char)"/>.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.CategoryPath.CompareTo(Lucene.Net.Facet.Taxonomy.CategoryPath)">
            <summary>
            Compares this path with another <see cref="T:Lucene.Net.Facet.Taxonomy.CategoryPath"/> for lexicographic
            order.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.CategoryPath.CopyFullPath(System.Char[],System.Int32,System.Char)">
            <summary>
            Copies the path components to the given <see cref="T:char[]"/>, starting at index
            <paramref name="start"/>. <paramref name="delimiter"/> is copied between the path components.
            Returns the number of chars copied.
            
            <para>
            <b>NOTE:</b> this method relies on the array being large enough to hold the
            components and separators - the amount of needed space can be calculated
            with <see cref="P:Lucene.Net.Facet.Taxonomy.CategoryPath.FullPathLength"/>.
            </para>
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.CategoryPath.Int64HashCode">
            <summary>
            Calculate a 64-bit hash function for this path.
            <para/>
            NOTE: This was longHashCode() in Lucene
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.CategoryPath.Subpath(System.Int32)">
            <summary>
            Returns a sub-path of this path up to <paramref name="length"/> components.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.CategoryPath.ToString">
            <summary>
            Returns a string representation of the path, separating components with
            '/'.
            </summary>
            <seealso cref="M:Lucene.Net.Facet.Taxonomy.CategoryPath.ToString(System.Char)"/>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.CategoryPath.ToString(System.Char)">
            <summary>
            Returns a string representation of the path, separating components with the
            given delimiter.
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.Taxonomy.Directory.Consts">
            <summary>
            @lucene.experimental
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyIndexReaderFactory">
            <summary>
            This class offers some hooks for extending classes to control the
            <see cref="T:Lucene.Net.Index.IndexReader"/> instance that is used by <see cref="T:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyReader"/>.
            <para/>
            This class is specific to Lucene.NET to allow to customize the <see cref="T:Lucene.Net.Index.DirectoryReader"/> instance
            before it is used by <see cref="T:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyReader"/>.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyIndexReaderFactory.OpenIndexReader(Lucene.Net.Store.Directory)">
            <summary>
            Open the <see cref="T:Lucene.Net.Index.DirectoryReader"/> from this <see cref="T:Lucene.Net.Store.Directory"/>. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyIndexReaderFactory.OpenIndexReader(Lucene.Net.Index.IndexWriter)">
            <summary>
            Open the <see cref="T:Lucene.Net.Index.DirectoryReader"/> from this <see cref="T:Lucene.Net.Index.IndexWriter"/>. 
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyIndexWriterFactory">
            <summary>
            This class offers some hooks for extending classes to control the
            <see cref="T:Lucene.Net.Index.IndexWriter"/> instance that is used by <see cref="T:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter"/>.
            <para/>
            This class is specific to Lucene.NET to allow to customize the <see cref="T:Lucene.Net.Index.IndexWriter"/> instance
            and its configuration before it is used by <see cref="T:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter"/>.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyIndexWriterFactory.OpenIndexWriter(Lucene.Net.Store.Directory,Lucene.Net.Index.IndexWriterConfig)">
            <summary>
            Open internal index writer, which contains the taxonomy data.
            <para/>
            Extensions may provide their own <see cref="T:Lucene.Net.Index.IndexWriter"/> implementation or instance. 
            <para/>
            <b>NOTE:</b> the instance this method returns will be disposed upon calling
            to <see cref="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.Dispose"/>.
            <para/>
            <b>NOTE:</b> the merge policy in effect must not merge none adjacent segments. See
            comment in <see cref="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyIndexWriterFactory.CreateIndexWriterConfig(Lucene.Net.Index.OpenMode)"/> for the logic behind this.
            </summary>
            <seealso cref="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyIndexWriterFactory.CreateIndexWriterConfig(Lucene.Net.Index.OpenMode)"/>
            <param name="directory">
                     the <see cref="T:Lucene.Net.Store.Directory"/> on top of which an <see cref="T:Lucene.Net.Index.IndexWriter"/>
                     should be opened. </param>
            <param name="config">
                     configuration for the internal index writer. </param>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyIndexWriterFactory.CreateIndexWriterConfig(Lucene.Net.Index.OpenMode)">
            <summary>
            Create the <see cref="T:Lucene.Net.Index.IndexWriterConfig"/> that would be used for opening the internal index writer.
            <para/>
            Extensions can configure the <see cref="T:Lucene.Net.Index.IndexWriter"/> as they see fit,
            including setting a <see cref="T:Lucene.Net.Index.MergeScheduler"/>, or
            <see cref="T:Lucene.Net.Index.IndexDeletionPolicy"/>, different RAM size
            etc.
            <para/>
            <b>NOTE:</b> internal docids of the configured index must not be altered.
            For that, categories are never deleted from the taxonomy index.
            In addition, merge policy in effect must not merge none adjacent segments.
            </summary>
            <seealso cref="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyIndexWriterFactory.OpenIndexWriter(Lucene.Net.Store.Directory,Lucene.Net.Index.IndexWriterConfig)"/>
            <param name="openMode"> see <see cref="T:Lucene.Net.Index.OpenMode"/> </param>
        </member>
        <member name="T:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyReader">
            <summary>
            A <see cref="T:Lucene.Net.Facet.Taxonomy.TaxonomyReader"/> which retrieves stored taxonomy information from a
            <see cref="T:Lucene.Net.Store.Directory"/>.
            <para/>
            Reading from the on-disk index on every method call is too slow, so this
            implementation employs caching: Some methods cache recent requests and their
            results, while other methods prefetch all the data into memory and then
            provide answers directly from in-memory tables. See the documentation of
            individual methods for comments on their performance.
            
            @lucene.experimental
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyReader.Int32Class">
            <summary>
            LUCENENET specific class to make an <see cref="T:System.Int32"/> type into a reference type.
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyReader.Int32Class.Value">
            <summary>
            NOTE: This was intItem (field) in Lucene
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyReader.#ctor(Lucene.Net.Index.DirectoryReader,Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter,Lucene.Net.Facet.Taxonomy.LruDictionary{Lucene.Net.Facet.Taxonomy.FacetLabel,Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyReader.Int32Class},Lucene.Net.Facet.Taxonomy.LruDictionary{System.Int32,Lucene.Net.Facet.Taxonomy.FacetLabel},Lucene.Net.Facet.Taxonomy.Directory.TaxonomyIndexArrays)">
            <summary>
            Called only from <see cref="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyReader.DoOpenIfChanged"/>. If the taxonomy has been
            recreated, you should pass <c>null</c> as the caches and parent/children
            arrays.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyReader.#ctor(Lucene.Net.Store.Directory)">
            <summary>
            Open for reading a taxonomy stored in a given <see cref="T:Lucene.Net.Store.Directory"/>. Uses <see cref="P:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyIndexReaderFactory.Default"/> as
            for <see cref="T:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyIndexReaderFactory"/>.
            </summary>
            <param name="directory"> The <see cref="T:Lucene.Net.Store.Directory"/> in which the taxonomy resides. </param>
            <exception cref="T:Lucene.Net.Index.CorruptIndexException"> if the Taxonomy is corrupt. </exception>
            <exception cref="T:System.IO.IOException"> if another error occurred. </exception>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyReader.#ctor(Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyIndexReaderFactory,Lucene.Net.Store.Directory)">
            <summary>
            Open for reading a taxonomy stored in a given <see cref="T:Lucene.Net.Store.Directory"/>.
            </summary>
            <param name="indexReaderFactory"> The <see cref="T:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyIndexReaderFactory"/> to use to open the index reader. </param>
            <param name="directory"> The <see cref="T:Lucene.Net.Store.Directory"/> in which the taxonomy resides. </param>
            <exception cref="T:Lucene.Net.Index.CorruptIndexException"> if the Taxonomy is corrupt. </exception>
            <exception cref="T:System.IO.IOException"> if another error occurred. </exception>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyReader.#ctor(Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter)">
            <summary>
            Opens a <see cref="T:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyReader"/> over the given
            <see cref="T:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter"/> (for NRT). Uses <see cref="P:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyIndexReaderFactory.Default"/>
            for <see cref="T:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyIndexReaderFactory"/>.
            </summary>
            <param name="taxoWriter">
                     The <see cref="T:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter"/> from which to obtain newly
                     added categories, in real-time. </param>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyReader.#ctor(Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyIndexReaderFactory,Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter)">
            <summary>
            Opens a <see cref="T:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyReader"/> over the given
            <see cref="T:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter"/> (for NRT).
            </summary>
            <param name="indexReaderFactory"> The <see cref="T:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyIndexReaderFactory"/> to use to open the index reader. </param>
            <param name="taxoWriter">
                     The <see cref="T:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter"/> from which to obtain newly
                     added categories, in real-time. </param>
            <exception cref="T:System.ArgumentNullException"> if <paramref name="indexReaderFactory"/> or <paramref name="taxoWriter"/> is <c>null</c>. </exception>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyReader.DoOpenIfChanged">
            <summary>
            Implements the opening of a new <see cref="T:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyReader"/> instance if
            the taxonomy has changed.
            
            <para>
            <b>NOTE:</b> the returned <see cref="T:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyReader"/> shares the
            ordinal and category caches with this reader. This is not expected to cause
            any issues, unless the two instances continue to live. The reader
            guarantees that the two instances cannot affect each other in terms of
            correctness of the caches, however if the size of the cache is changed
            through <see cref="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyReader.SetCacheSize(System.Int32)"/>, it will affect both reader instances.
            </para>
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyReader.InternalIndexReader">
            LUCENENET specific - OpenIndexReader(Directory directory) and
            OpenIndexReader(IndexWriter writer) were
            moved to <see cref="T:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyIndexReaderFactory"/> to allow extended classes
            to customize writer behavior. This is a breaking change from Lucene, and required
            in order to offer the same functionality in .NET as Lucene offers in Java. These virtual methods
            were being called from the constructors and have different initialization sequence in .NET
            so a factory approach was used instead.
            <summary>
            Expert: returns the underlying <see cref="T:Lucene.Net.Index.DirectoryReader"/> instance that is
            used by this <see cref="T:Lucene.Net.Facet.Taxonomy.TaxonomyReader"/>.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyReader.SetCacheSize(System.Int32)">
            <summary>
            <see cref="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyReader.SetCacheSize(System.Int32)"/> controls the maximum allowed size of each of the caches
            used by <see cref="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyReader.GetPath(System.Int32)"/> and <see cref="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyReader.GetOrdinal(Lucene.Net.Facet.Taxonomy.FacetLabel)"/>.
            <para/>
            Currently, if the given size is smaller than the current size of
            a cache, it will not shrink, and rather we be limited to its current
            size. </summary>
            <param name="size"> The new maximum cache size, in number of entries. </param>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyReader.ToString(System.Int32)">
            <summary>
            Returns ordinal -> label mapping, up to the provided
            max ordinal or number of ordinals, whichever is
            smaller. 
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter">
             <summary>
             <see cref="T:Lucene.Net.Facet.Taxonomy.ITaxonomyWriter"/> which uses a <see cref="T:Lucene.Net.Store.Directory"/> to store the taxonomy
             information on disk, and keeps an additional in-memory cache of some or all
             categories.
             <para>
             In addition to the permanently-stored information in the <see cref="T:Lucene.Net.Store.Directory"/>,
             efficiency dictates that we also keep an in-memory cache of <b>recently
             seen</b> or <b>all</b> categories, so that we do not need to go back to disk
             for every category addition to see which ordinal this category already has,
             if any. A <see cref="T:Lucene.Net.Facet.Taxonomy.WriterCache.ITaxonomyWriterCache"/> object determines the specific caching
             algorithm used.
             </para>
             <para>
             For extending classes that need to control the <see cref="T:Lucene.Net.Index.IndexWriter"/> instance that is used,
             please see <see cref="T:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyIndexWriterFactory"/> class.
            
             @lucene.experimental
             </para>
             </summary>
        </member>
        <member name="F:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.INDEX_EPOCH">
            <summary>
            Property name of user commit data that contains the index epoch. The epoch
            changes whenever the taxonomy is recreated (i.e. opened with
            <see cref="F:Lucene.Net.Index.OpenMode.CREATE"/>.
            <para>
            Applications should not use this property in their commit data because it
            will be overridden by this taxonomy writer.
            </para>
            </summary>
        </member>
        <member name="F:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.cacheIsComplete">
            <summary>
            We call the cache "complete" if we know that every category in our
            taxonomy is in the cache. When the cache is <b>not</b> complete, and
            we can't find a category in the cache, we still need to look for it
            in the on-disk index; Therefore when the cache is not complete, we
            need to open a "reader" to the taxonomy index.
            The cache becomes incomplete if it was never filled with the existing
            categories, or if a Put() to the cache ever returned true (meaning
            that some of the cached data was cleared).
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.ReadCommitData(Lucene.Net.Store.Directory)">
            <summary>
            Reads the commit data from a <see cref="T:Lucene.Net.Store.Directory"/>. </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.Unlock(Lucene.Net.Store.Directory)">
            <summary>
            Forcibly unlocks the taxonomy in the named directory.
            <para/>
            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 taxonomy.
            <para/>
            This method is unnecessary if your <see cref="T:Lucene.Net.Store.Directory"/> uses a
            <see cref="T:Lucene.Net.Store.NativeFSLockFactory"/> instead of the default
            <see cref="T:Lucene.Net.Store.SimpleFSLockFactory"/>. When the "native" lock is used, a lock
            does not stay behind forever when the process using it dies.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.#ctor(Lucene.Net.Store.Directory,Lucene.Net.Index.OpenMode,Lucene.Net.Facet.Taxonomy.WriterCache.ITaxonomyWriterCache)">
            <summary>
            Construct a Taxonomy writer.
            </summary>
            <param name="directory">
               The <see cref="T:Lucene.Net.Store.Directory"/> in which to store the taxonomy. Note that
               the taxonomy is written directly to that directory (not to a
               subdirectory of it). </param>
            <param name="openMode">
               Specifies how to open a taxonomy for writing: <see cref="F:Lucene.Net.Index.OpenMode.APPEND"/>
               means open an existing index for append (failing if the index does
               not yet exist). <see cref="F:Lucene.Net.Index.OpenMode.CREATE"/> means create a new index (first
               deleting the old one if it already existed).
               <see cref="F:Lucene.Net.Index.OpenMode.CREATE_OR_APPEND"/> appends to an existing index if there
               is one, otherwise it creates a new index. </param>
            <param name="cache">
               A <see cref="T:Lucene.Net.Facet.Taxonomy.WriterCache.ITaxonomyWriterCache"/> implementation which determines
               the in-memory caching policy. See for example
               <see cref="T:Lucene.Net.Facet.Taxonomy.WriterCache.LruTaxonomyWriterCache"/> and <see cref="T:Lucene.Net.Facet.Taxonomy.WriterCache.Cl2oTaxonomyWriterCache"/>.
               If null or missing, <see cref="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.CreateDefaultTaxonomyWriterCache"/> is used. </param>
            <exception cref="T:Lucene.Net.Index.CorruptIndexException">
                if the taxonomy is corrupted. </exception>
            <exception cref="T:Lucene.Net.Store.LockObtainFailedException">
                if the taxonomy is locked by another writer. If it is known
                that no other concurrent writer is active, the lock might
                have been left around by an old dead process, and should be
                removed using <see cref="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.Unlock(Lucene.Net.Store.Directory)"/>. </exception>
            <exception cref="T:System.IO.IOException">
                if another error occurred. </exception>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.#ctor(Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyIndexWriterFactory,Lucene.Net.Store.Directory,Lucene.Net.Index.OpenMode,Lucene.Net.Facet.Taxonomy.WriterCache.ITaxonomyWriterCache)">
            <summary>
            Construct a Taxonomy writer.
            </summary>
            <para />
            NOTE to inheritors: This constructor in some cases can call AddCategory to add the root category
            (e.g. if the index is empty). Therefore, if you override the AddCategory method, you should be aware
            that it will be called from this constructor and some of your state might not be fully initialized at that time.
            <param name="directory">
               The <see cref="T:Lucene.Net.Store.Directory"/> in which to store the taxonomy. Note that
               the taxonomy is written directly to that directory (not to a
               subdirectory of it). </param>
            <param name="openMode">
               Specifies how to open a taxonomy for writing: <see cref="F:Lucene.Net.Index.OpenMode.APPEND"/>
               means open an existing index for append (failing if the index does
               not yet exist). <see cref="F:Lucene.Net.Index.OpenMode.CREATE"/> means create a new index (first
               deleting the old one if it already existed).
               <see cref="F:Lucene.Net.Index.OpenMode.CREATE_OR_APPEND"/> appends to an existing index if there
               is one, otherwise it creates a new index. </param>
            <param name="cache">
               A <see cref="T:Lucene.Net.Facet.Taxonomy.WriterCache.ITaxonomyWriterCache"/> implementation which determines
               the in-memory caching policy. See for example
               <see cref="T:Lucene.Net.Facet.Taxonomy.WriterCache.LruTaxonomyWriterCache"/> and <see cref="T:Lucene.Net.Facet.Taxonomy.WriterCache.Cl2oTaxonomyWriterCache"/>.
               If null or missing, <see cref="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.CreateDefaultTaxonomyWriterCache"/> is used. </param>
            <param name="indexWriterFactory">
               A <see cref="T:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyIndexWriterFactory"/> implementation that can be used to
               customize the <see cref="T:Lucene.Net.Index.IndexWriter"/> configuration and writer itself that's used to
               store the taxonomy index.</param>
            <exception cref="T:Lucene.Net.Index.CorruptIndexException">
                if the taxonomy is corrupted. </exception>
            <exception cref="T:Lucene.Net.Store.LockObtainFailedException">
                if the taxonomy is locked by another writer. If it is known
                that no other concurrent writer is active, the lock might
                have been left around by an old dead process, and should be
                removed using <see cref="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.Unlock(Lucene.Net.Store.Directory)"/>. </exception>
            <exception cref="T:System.IO.IOException">
                if another error occurred. </exception>
            <exception cref="T:System.ArgumentNullException"> if <paramref name="indexWriterFactory"/> is <c>null</c> </exception>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.InitReaderManager">
            LUCENENET specific - OpenIndexWriter(Directory directory, IndexWriterConfig config)
            and protected virtual IndexWriterConfig CreateIndexWriterConfig(OpenMode openMode) were
            moved to <see cref="T:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyIndexWriterFactory"/> to allow extended classes
            to customize the configs and writers. This is a breaking change from Lucene, and required
            in order to offer the same functionality in .NET as Lucene offers in Java. These virtual methods
            were being called from the constructors and have different initialization sequence in .NET
            so a factory approach was used instead.
            <summary>
            Opens a <see cref="T:Lucene.Net.Index.ReaderManager"/> from the internal <see cref="T:Lucene.Net.Index.IndexWriter"/>.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.#ctor(Lucene.Net.Store.Directory,Lucene.Net.Index.OpenMode)">
            <summary>
            Creates a new instance with a default cache as defined by
            <see cref="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.CreateDefaultTaxonomyWriterCache"/>.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.CreateDefaultTaxonomyWriterCache">
            <summary>
            Defines the default <see cref="T:Lucene.Net.Facet.Taxonomy.WriterCache.ITaxonomyWriterCache"/> to use in constructors
            which do not specify one.
            <para>
            The current default is <see cref="T:Lucene.Net.Facet.Taxonomy.WriterCache.Cl2oTaxonomyWriterCache"/> constructed
            with the parameters (1024, 0.15f, 3), i.e., the entire taxonomy is
            cached in memory while building it.
            </para>
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.#ctor(Lucene.Net.Store.Directory)">
            <summary>
            Create this with <see cref="F:Lucene.Net.Index.OpenMode.CREATE_OR_APPEND"/>.
            </summary>
            <param name="directory">The <see cref="T:Lucene.Net.Store.Directory"/> in which to store the taxonomy. Note that
               the taxonomy is written directly to that directory (not to a
               subdirectory of it). </param>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.#ctor(Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyIndexWriterFactory,Lucene.Net.Store.Directory)">
            <summary>
            Create this with <see cref="F:Lucene.Net.Index.OpenMode.CREATE_OR_APPEND"/> and <see cref="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.CreateDefaultTaxonomyWriterCache"/>.
            </summary>
            <param name="indexWriterFactory">The <see cref="T:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyIndexWriterFactory"/> to use to create the <see cref="T:Lucene.Net.Index.IndexWriter"/>.</param>
            <param name="directory">The <see cref="T:Lucene.Net.Store.Directory"/> in which to store the taxonomy. Note that
               the taxonomy is written directly to that directory (not to a
               subdirectory of it). </param>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.Dispose">
            <summary>
            Frees used resources as well as closes the underlying <see cref="T:Lucene.Net.Index.IndexWriter"/>,
            which commits whatever changes made to it to the underlying
            <see cref="T:Lucene.Net.Store.Directory"/>.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.Dispose(System.Boolean)">
            <summary>
            A hook for extending classes to close additional resources that were used.
            The default implementation closes the <see cref="T:Lucene.Net.Index.IndexReader"/> as well as the
            <see cref="T:Lucene.Net.Facet.Taxonomy.WriterCache.ITaxonomyWriterCache"/> instances that were used.
            <para>
            <b>NOTE:</b> if you override this method, you should include a
            <c>base.Dispose(disposing)</c> call in your implementation.
            </para>
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.CloseResources">
            <summary>
            Closes the <see cref="T:Lucene.Net.Index.IndexReader"/> as well as the
            <see cref="T:Lucene.Net.Facet.Taxonomy.WriterCache.ITaxonomyWriterCache"/> instances that were used.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.FindCategory(Lucene.Net.Facet.Taxonomy.FacetLabel)">
            <summary>
            Look up the given category in the cache and/or the on-disk storage,
            returning the category's ordinal, or a negative number in case the
            category does not yet exist in the taxonomy.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.AddCategory(Lucene.Net.Facet.Taxonomy.FacetLabel)">
            <summary>
            NOTE to inheritors: This method can be called from the constructor to add the root category
            (e.g. if the index is empty). Therefore, if you override the AddCategory method, you should be aware
            that it will be called before your state is fully initialized.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.InternalAddCategory(Lucene.Net.Facet.Taxonomy.FacetLabel)">
            <summary>
            Add a new category into the index (and the cache), and return its new
            ordinal.
            <para>
            Actually, we might also need to add some of the category's ancestors
            before we can add the category itself (while keeping the invariant that a
            parent is always added to the taxonomy before its child). We do this by
            recursion.
            </para>
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.EnsureOpen">
            <summary>
            Verifies that this instance wasn't closed, or throws
            <see cref="T:System.ObjectDisposedException"/> if it is.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.AddCategoryDocument(Lucene.Net.Facet.Taxonomy.FacetLabel,System.Int32)">
            <summary>
            Note that the methods calling <see cref="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.AddCategoryDocument(Lucene.Net.Facet.Taxonomy.FacetLabel,System.Int32)"/> are synchornized, so
            this method is effectively synchronized as well.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.SinglePositionTokenStream.Set(System.Int32)">
            <summary>
            Set the value we want to keep, as the position increment.
            Note that when TermPositions.NextPosition() is later used to
            retrieve this value, val-1 will be returned, not val.
            <para>
            IMPORTANT NOTE: Before Lucene 2.9, val>=0 were safe (for val==0,
            the retrieved position would be -1). But starting with Lucene 2.9,
            this unfortunately changed, and only val>0 are safe. val=0 can
            still be used, but don't count on the value you retrieve later
            (it could be 0 or -1, depending on circumstances or versions).
            This change is described in Lucene's JIRA: LUCENE-1542.
            </para>
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.CombinedCommitData(System.Collections.Generic.IDictionary{System.String,System.String})">
            <summary>
            Combine original user data with the taxonomy epoch.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.PrepareCommit">
            <summary>
            prepare most of the work needed for a two-phase commit.
            See <see cref="M:Lucene.Net.Index.IndexWriter.PrepareCommit"/>.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.SetCacheMissesUntilFill(System.Int32)">
            <summary>
            Set the number of cache misses before an attempt is made to read the entire
            taxonomy into the in-memory cache.
            <para>
            This taxonomy writer holds an in-memory cache of recently seen categories
            to speed up operation. On each cache-miss, the on-disk index needs to be
            consulted. When an existing taxonomy is opened, a lot of slow disk reads
            like that are needed until the cache is filled, so it is more efficient to
            read the entire taxonomy into memory at once. We do this complete read
            after a certain number (defined by this method) of cache misses.
            </para>
            <para>
            If the number is set to <c>0</c>, the entire taxonomy is read into the
            cache on first use, without fetching individual categories first.
            </para>
            <para>
            NOTE: it is assumed that this method is called immediately after the
            taxonomy writer has been created.
            </para>
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.AddTaxonomy(Lucene.Net.Store.Directory,Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.IOrdinalMap)">
            <summary>
            Takes the categories from the given taxonomy directory, and adds the
            missing ones to this taxonomy. Additionally, it fills the given
            <see cref="T:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.IOrdinalMap"/> with a mapping from the original ordinal to the new
            ordinal.
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.IOrdinalMap">
            <summary>
            Mapping from old ordinal to new ordinals, used when merging indexes
            wit separate taxonomies.
            <para/>
            <see cref="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.IOrdinalMap.AddMapping(System.Int32,System.Int32)"/> merges one or more taxonomies into the given taxonomy
            (this). An <see cref="T:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.IOrdinalMap"/> is filled for each of the added taxonomies,
            containing the new ordinal (in the merged taxonomy) of each of the
            categories in the old taxonomy.
            <para/>
            There exist two implementations of <see cref="T:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.IOrdinalMap"/>: <see cref="T:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.MemoryOrdinalMap"/> and
            <see cref="T:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.DiskOrdinalMap"/>. As their names suggest, the former keeps the map in
            memory and the latter in a temporary disk file. Because these maps will
            later be needed one by one (to remap the counting lists), not all at the
            same time, it is recommended to put the first taxonomy's map in memory,
            and all the rest on disk (later to be automatically read into memory one
            by one, when needed).
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.IOrdinalMap.SetSize(System.Int32)">
            <summary>
            Set the size of the map. This MUST be called before <see cref="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.IOrdinalMap.AddMapping(System.Int32,System.Int32)"/>.
            It is assumed (but not verified) that <see cref="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.IOrdinalMap.AddMapping(System.Int32,System.Int32)"/> will then be
            called exactly 'size' times, with different <c>origOrdinals</c> between 0
            and size - 1.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.IOrdinalMap.AddMapping(System.Int32,System.Int32)">
            <summary>
            Record a mapping. </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.IOrdinalMap.AddDone">
            <summary>
            Call <see cref="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.IOrdinalMap.AddDone"/> to say that all <see cref="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.IOrdinalMap.AddMapping(System.Int32,System.Int32)"/> have been done.
            In some implementations this might free some resources.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.IOrdinalMap.GetMap">
            <summary>
            Return the map from the taxonomy's original (consecutive) ordinals
            to the new taxonomy's ordinals. If the map has to be read from disk
            and ordered appropriately, it is done when getMap() is called.
            getMap() should only be called once, and only when the map is actually
            needed. Calling it will also free all resources that the map might
            be holding (such as temporary disk space), other than the returned int[].
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.MemoryOrdinalMap">
            <summary>
            <see cref="T:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.IOrdinalMap"/> maintained in memory
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.MemoryOrdinalMap.#ctor">
            <summary>
            Sole constructor.
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.DiskOrdinalMap">
            <summary>
            <see cref="T:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.IOrdinalMap"/> maintained on file system
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.DiskOrdinalMap.#ctor(System.String)">
            <summary>
            Sole constructor.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.Rollback">
            <summary>
            Rollback changes to the taxonomy writer and closes the instance. Following
            this method the instance becomes unusable (calling any of its API methods
            will yield an <see cref="T:System.ObjectDisposedException"/>).
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.ReplaceTaxonomy(Lucene.Net.Store.Directory)">
            <summary>
            Replaces the current taxonomy with the given one. This method should
            generally be called in conjunction with
            <see cref="M:Lucene.Net.Index.IndexWriter.AddIndexes(Lucene.Net.Store.Directory[])"/> to replace both the taxonomy
            as well as the search index content.
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.Directory">
            <summary>
            Returns the <see cref="T:Lucene.Net.Store.Directory"/> of this taxonomy writer.
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.InternalIndexWriter">
            <summary>
            Used by <see cref="T:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyReader"/> to support NRT.
            <para>
            <b>NOTE:</b> you should not use the obtained <see cref="T:Lucene.Net.Index.IndexWriter"/> in any
            way, other than opening an IndexReader on it, or otherwise, the taxonomy
            index may become corrupt!
            </para>
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.TaxonomyEpoch">
             <summary>
             Expert: returns current index epoch, if this is a
             near-real-time reader.  Used by
             <see cref="T:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyReader"/> to support NRT.
            
             @lucene.internal
             </summary>
        </member>
        <member name="T:Lucene.Net.Facet.Taxonomy.Directory.TaxonomyIndexArrays">
            <summary>
            A <see cref="T:Lucene.Net.Facet.Taxonomy.ParallelTaxonomyArrays"/> that are initialized from the taxonomy
            index.
            
            @lucene.experimental
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.Directory.TaxonomyIndexArrays.#ctor(System.Int32[])">
            <summary>
            Used by <see cref="M:Lucene.Net.Facet.Taxonomy.Directory.TaxonomyIndexArrays.Add(System.Int32,System.Int32)"/> after the array grew.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.Directory.TaxonomyIndexArrays.InitParents(Lucene.Net.Index.IndexReader,System.Int32)">
            <summary>
            Read the parents of the new categories
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.Directory.TaxonomyIndexArrays.Add(System.Int32,System.Int32)">
            <summary>
            Adds the given ordinal/parent info and returns either a new instance if the
            underlying array had to grow, or this instance otherwise.
            <para>
            <b>NOTE:</b> you should call this method from a thread-safe code.
            </para>
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.Taxonomy.Directory.TaxonomyIndexArrays.Parents">
            <summary>
            Returns the parents array, where <c>Parents[i]</c> denotes the parent of
            category ordinal <c>i</c>.
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.Taxonomy.Directory.TaxonomyIndexArrays.Children">
            <summary>
            Returns the children array, where <c>Children[i]</c> denotes the youngest
            child of category ordinal <c>i</c>. The youngest child is defined as the
            category that was added last to the taxonomy as an immediate child of
            <c>i</c>.
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.Taxonomy.Directory.TaxonomyIndexArrays.Siblings">
            <summary>
            Returns the siblings array, where <c>Siblings[i]</c> denotes the sibling
            of category ordinal <c>i</c>. The sibling is defined as the previous
            youngest child of <c>Parents[i]</c>.
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.Taxonomy.DocValuesOrdinalsReader">
            <summary>
            Decodes ordinals previously indexed into a <see cref="T:Lucene.Net.Index.BinaryDocValues"/> field
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.DocValuesOrdinalsReader.#ctor">
            <summary>
            Default constructor.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.DocValuesOrdinalsReader.#ctor(System.String)">
            <summary>
            Create this, with the specified indexed field name.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.DocValuesOrdinalsReader.Decode(Lucene.Net.Util.BytesRef,Lucene.Net.Util.Int32sRef)">
            <summary>
            Subclass &amp; override if you change the encoding.
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.Taxonomy.FacetLabel">
            <summary>
            Holds a sequence of string components, specifying the hierarchical name of a
            category.
            
            @lucene.internal
            </summary>
        </member>
        <member name="F:Lucene.Net.Facet.Taxonomy.FacetLabel.MAX_CATEGORY_PATH_LENGTH">
            <summary>
            The maximum number of characters a <see cref="T:Lucene.Net.Facet.Taxonomy.FacetLabel"/> can have.
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.Taxonomy.FacetLabel.Components">
            <summary>
            The components of this <see cref="T:Lucene.Net.Facet.Taxonomy.FacetLabel"/>. Note that this array may be
            shared with other <see cref="T:Lucene.Net.Facet.Taxonomy.FacetLabel"/> instances, e.g. as a result of
            <see cref="M:Lucene.Net.Facet.Taxonomy.FacetLabel.Subpath(System.Int32)"/>, therefore you should traverse the array up to
            <see cref="P:Lucene.Net.Facet.Taxonomy.FacetLabel.Length"/> for this path's components.
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.Taxonomy.FacetLabel.Length">
            <summary>
            The number of components of this <see cref="T:Lucene.Net.Facet.Taxonomy.FacetLabel"/>.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.FacetLabel.#ctor(System.String[])">
            <summary>
            Construct from the given path components.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.FacetLabel.#ctor(System.String,System.String[])">
            <summary>
            Construct from the dimension plus the given path components.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.FacetLabel.CompareTo(Lucene.Net.Facet.Taxonomy.FacetLabel)">
            <summary>
            Compares this path with another <see cref="T:Lucene.Net.Facet.Taxonomy.FacetLabel"/> for lexicographic
            order.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.FacetLabel.Int64HashCode">
            <summary>
            Calculate a 64-bit hash function for this path.  This
            is necessary for <see cref="T:Lucene.Net.Facet.Taxonomy.WriterCache.NameHashInt32CacheLru"/> (the
            default cache impl for <see cref="T:Lucene.Net.Facet.Taxonomy.WriterCache.LruTaxonomyWriterCache"/>) 
            to reduce the chance of "silent but deadly" collisions.
            <para/>
            NOTE: This was longHashCode() in Lucene
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.FacetLabel.Subpath(System.Int32)">
            <summary>
            Returns a sub-path of this path up to <paramref name="length"/> components.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.FacetLabel.ToString">
            <summary>
            Returns a string representation of the path.
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.Taxonomy.FastTaxonomyFacetCounts">
            <summary>
            Computes facets counts, assuming the default encoding
            into DocValues was used.
            
            @lucene.experimental 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.FastTaxonomyFacetCounts.#ctor(Lucene.Net.Facet.Taxonomy.TaxonomyReader,Lucene.Net.Facet.FacetsConfig,Lucene.Net.Facet.FacetsCollector)">
            <summary>
            Create <see cref="T:Lucene.Net.Facet.Taxonomy.FastTaxonomyFacetCounts"/>, which also
            counts all facet labels. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.FastTaxonomyFacetCounts.#ctor(System.String,Lucene.Net.Facet.Taxonomy.TaxonomyReader,Lucene.Net.Facet.FacetsConfig,Lucene.Net.Facet.FacetsCollector)">
            <summary>
            Create <see cref="T:Lucene.Net.Facet.Taxonomy.FastTaxonomyFacetCounts"/>, using the
            specified <paramref name="indexFieldName"/> for ordinals.  Use
            this if you had set <see cref="M:Lucene.Net.Facet.FacetsConfig.SetIndexFieldName(System.String,System.String)"/>
            to change the index
            field name for certain dimensions. 
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.Taxonomy.SingleAssociationFacetField">
            <summary>
            Add an instance of this to your <see cref="T:Lucene.Net.Documents.Document"/> to add
            a facet label associated with a <see cref="T:System.Single"/>.  Use <see cref="T:Lucene.Net.Facet.Taxonomy.TaxonomyFacetSumSingleAssociations"/>
            to aggregate <see cref="T:System.Single"/> values per facet label at search time.
            <para/>
            NOTE: This was FloatAssociationFacetField in Lucene
            <para/>
            @lucene.experimental 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.SingleAssociationFacetField.#ctor(System.Single,System.String,System.String[])">
            <summary>
            Creates this from <paramref name="dim"/> and <paramref name="path"/> and a
            <see cref="T:System.Single"/> association 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.SingleAssociationFacetField.SingleToBytesRef(System.Single)">
            <summary>
            Encodes a <see cref="T:System.Single"/> as a 4-byte <see cref="T:Lucene.Net.Util.BytesRef"/>.
            <para/>
            NOTE: This was floatToBytesRef() in Lucene
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.SingleAssociationFacetField.BytesRefToSingle(Lucene.Net.Util.BytesRef)">
            <summary>
            Decodes a previously encoded <see cref="T:System.Single"/>.
            <para/>
            NOTE: This was bytesRefToFloat() in Lucene
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.Taxonomy.SingleTaxonomyFacets">
            <summary>
            Base class for all taxonomy-based facets that aggregate
            to a per-ords <see cref="T:float[]"/>.
            <para/>
            NOTE: This was FloatTaxonomyFacets in Lucene
            </summary>
        </member>
        <member name="F:Lucene.Net.Facet.Taxonomy.SingleTaxonomyFacets.m_values">
            <summary>
            Per-ordinal value. </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.SingleTaxonomyFacets.#ctor(System.String,Lucene.Net.Facet.Taxonomy.TaxonomyReader,Lucene.Net.Facet.FacetsConfig)">
            <summary>
            Sole constructor.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.SingleTaxonomyFacets.Rollup">
            <summary>
            Rolls up any single-valued hierarchical dimensions.
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.Taxonomy.Int32AssociationFacetField">
            <summary>
            Add an instance of this to your <see cref="T:Lucene.Net.Documents.Document"/> to add
            a facet label associated with an <see cref="T:System.Int32"/>.  Use <see cref="T:Lucene.Net.Facet.Taxonomy.TaxonomyFacetSumInt32Associations"/>
            to aggregate int values per facet label at search time.
            <para/>
            NOTE: This was IntAssociationFacetField in Lucene
            <para/>
            @lucene.experimental 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.Int32AssociationFacetField.#ctor(System.Int32,System.String,System.String[])">
            <summary>
            Creates this from <paramref name="dim"/> and <paramref name="path"/> and an
            int association 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.Int32AssociationFacetField.Int32ToBytesRef(System.Int32)">
            <summary>
            Encodes an <see cref="T:System.Int32"/> as a 4-byte <see cref="T:Lucene.Net.Util.BytesRef"/>,
            big-endian.
            <para/>
            NOTE: This was intToBytesRef() in Lucene
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.Int32AssociationFacetField.BytesRefToInt32(Lucene.Net.Util.BytesRef)">
            <summary>
            Decodes a previously encoded <see cref="T:System.Int32"/>.
            <para/>
            NOTE: This was bytesRefToInt() in Lucene
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.Taxonomy.Int32TaxonomyFacets">
            <summary>
            Base class for all taxonomy-based facets that aggregate
            to a per-ords <see cref="T:int[]"/>.
            <para/>
            NOTE: This was IntTaxonomyFacets in Lucene
            </summary>
        </member>
        <member name="F:Lucene.Net.Facet.Taxonomy.Int32TaxonomyFacets.m_values">
            <summary>
            Per-ordinal value. </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.Int32TaxonomyFacets.#ctor(System.String,Lucene.Net.Facet.Taxonomy.TaxonomyReader,Lucene.Net.Facet.FacetsConfig)">
            <summary>
            Sole constructor.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.Int32TaxonomyFacets.Rollup">
            <summary>
            Rolls up any single-valued hierarchical dimensions.
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.Taxonomy.LruDictionary`2">
            <summary>
            <see cref="T:Lucene.Net.Facet.Taxonomy.LruDictionary`2"/> is similar to of Java's HashMap, which has a bounded <see cref="P:Lucene.Net.Facet.Taxonomy.LruDictionary`2.Limit"/>;
            When it reaches that <see cref="P:Lucene.Net.Facet.Taxonomy.LruDictionary`2.Limit"/>, each time a new element is added, the least
            recently used (LRU) entry is removed.
            <para>
            Unlike the Java Lucene implementation, this one is thread safe because it is backed by the <see cref="T:J2N.Collections.Concurrent.LurchTable`2"/>.
            Do note that every time an element is read from <see cref="T:Lucene.Net.Facet.Taxonomy.LruDictionary`2"/>,
            a write operation also takes place to update the element's last access time.
            This is because the LRU order needs to be remembered to determine which element
            to evict when the <see cref="P:Lucene.Net.Facet.Taxonomy.LruDictionary`2.Limit"/> is exceeded. 
            </para>
            <para>
            
            @lucene.experimental
            </para>
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.LruDictionary`2.#ctor(System.Int32)">
            <summary>
            Create a new hash map with a bounded size and with least recently
            used entries removed.
            </summary>
            <param name="limit">
            The maximum size (in number of entries) to which the map can grow
            before the least recently used entries start being removed.
            <para/>
            Setting <paramref name="limit"/> to a very large value, like <see cref="F:System.Int32.MaxValue"/>
            is allowed, but is less efficient than
            using <see cref="T:J2N.Collections.Generic.Dictionary`2"/> or 
            <see cref="T:System.Collections.Generic.Dictionary`2"/> because our class needs
            to keep track of the use order (via an additional doubly-linked
            list) which is not used when the map's size is always below the
            maximum size.
            </param>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.LruDictionary`2.#ctor(System.Int32,System.Collections.Generic.IEqualityComparer{`0})">
            <summary>
            Create a new hash map with a bounded size and with least recently
            used entries removed.
            <para/>
            LUCENENET specific overload to allow passing in custom <see cref="T:System.Collections.Generic.IEqualityComparer`1"/>. 
            See LUCENENET-602.
            </summary>
            <param name="limit">
            The maximum size (in number of entries) to which the map can grow
            before the least recently used entries start being removed.
            <para/>
            Setting <paramref name="limit"/> to a very large value, like <see cref="F:System.Int32.MaxValue"/>
            is allowed, but is less efficient than
            using <see cref="T:J2N.Collections.Generic.Dictionary`2"/> or 
            <see cref="T:System.Collections.Generic.Dictionary`2"/> because our class needs
            to keep track of the use order (via an additional doubly-linked
            list) which is not used when the map's size is always below the
            maximum size.
            </param>
            <param name="comparer">
            The <see cref="T:System.Collections.Generic.IEqualityComparer`1"/> implementation to use when comparing keys, 
            or <c>null</c> to use the default <see cref="T:System.Collections.Generic.IEqualityComparer`1"/> for the type of the key.
            </param>
        </member>
        <member name="P:Lucene.Net.Facet.Taxonomy.LruDictionary`2.Limit">
            <summary>
            Allows changing the dictionary's maximal number of elements
            which was defined at construction time.
            <para>
            Note that if the dictionary is already larger than <see cref="P:Lucene.Net.Facet.Taxonomy.LruDictionary`2.Limit"/>, the current 
            implementation does not shrink it (by removing the oldest elements);
            Rather, the map remains in its current size as new elements are
            added, and will only start shrinking (until settling again on the
            given <see cref="P:Lucene.Net.Facet.Taxonomy.LruDictionary`2.Limit"/>) if existing elements are explicitly deleted.
            </para>
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.Taxonomy.OrdinalsReader">
            <summary>
            Provides per-document ordinals. 
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.Taxonomy.OrdinalsReader.OrdinalsSegmentReader">
            <summary>
            Returns ordinals for documents in one segment.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.OrdinalsReader.OrdinalsSegmentReader.Get(System.Int32,Lucene.Net.Util.Int32sRef)">
            <summary>
            Get the ordinals for this document. The <paramref name="ordinals"/>.<see cref="P:Lucene.Net.Util.Int32sRef.Offset"/>
            must always be 0! 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.OrdinalsReader.OrdinalsSegmentReader.#ctor">
            <summary>
            Default constructor. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.OrdinalsReader.#ctor">
            <summary>
            Default constructor. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.OrdinalsReader.GetReader(Lucene.Net.Index.AtomicReaderContext)">
            <summary>
            Set current atomic reader. 
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.Taxonomy.OrdinalsReader.IndexFieldName">
            <summary>
            Returns the indexed field name this <see cref="T:Lucene.Net.Facet.Taxonomy.OrdinalsReader"/>
            is reading from. 
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.Taxonomy.ParallelTaxonomyArrays">
            <summary>
            Returns 3 arrays for traversing the taxonomy:
            <list type="bullet">
            <item><description> <see cref="P:Lucene.Net.Facet.Taxonomy.ParallelTaxonomyArrays.Parents"/>: <c>Parents[i]</c> denotes the parent of category
            ordinal <c>i</c>.</description></item>
            <item><description> <see cref="P:Lucene.Net.Facet.Taxonomy.ParallelTaxonomyArrays.Children"/>: <c>Children[i]</c> denotes a child of category ordinal
            <c>i</c>.</description></item>
            <item><description> <see cref="P:Lucene.Net.Facet.Taxonomy.ParallelTaxonomyArrays.Siblings"/>: <c>Siblings[i]</c> denotes the sibling of category
            ordinal <c>i</c>.</description></item>
            </list>
            
            To traverse the taxonomy tree, you typically start with <c>Children[0]</c>
            (ordinal 0 is reserved for ROOT), and then depends if you want to do DFS or
            BFS, you call <c>Children[Children[0]]</c> or <c>Siblings[Children[0]]</c>
            and so forth, respectively.
            
            <para>
            <b>NOTE:</b> you are not expected to modify the values of the arrays, since
            the arrays are shared with other threads.
            
            @lucene.experimental
            </para>
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.ParallelTaxonomyArrays.#ctor">
            <summary>
            Sole constructor.
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.Taxonomy.ParallelTaxonomyArrays.Parents">
            <summary>
            Returns the parents array, where <c>Parents[i]</c> denotes the parent of
            category ordinal <c>i</c>.
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.Taxonomy.ParallelTaxonomyArrays.Children">
            <summary>
            Returns the children array, where <c>Children[i]</c> denotes a child of
            category ordinal <c>i</c>.
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.Taxonomy.ParallelTaxonomyArrays.Siblings">
            <summary>
            Returns the siblings array, where <c>Siblings[i]</c> denotes the sibling
            of category ordinal <c>i</c>.
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.Taxonomy.PrintTaxonomyStats">
            <summary>
            Prints how many ords are under each dimension. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.PrintTaxonomyStats.Main(System.String[])">
            <summary>
            Command-line tool.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.PrintTaxonomyStats.PrintStats(Lucene.Net.Facet.Taxonomy.TaxonomyReader,System.IO.TextWriter,System.Boolean)">
            <summary>
            Recursively prints stats for all ordinals. </summary>
        </member>
        <member name="T:Lucene.Net.Facet.Taxonomy.SearcherTaxonomyManager">
            <summary>
            Manages near-real-time reopen of both an <see cref="T:Lucene.Net.Search.IndexSearcher"/>
            and a <see cref="T:Lucene.Net.Facet.Taxonomy.TaxonomyReader"/>.
            
            <para>
            <b>NOTE</b>: If you call <see cref="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.ReplaceTaxonomy(Lucene.Net.Store.Directory)"/>
            then you must open a new <see cref="T:Lucene.Net.Facet.Taxonomy.SearcherTaxonomyManager"/> afterwards.
            </para>
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.Taxonomy.SearcherTaxonomyManager.SearcherAndTaxonomy">
            <summary>
            Holds a matched pair of <see cref="T:Lucene.Net.Search.IndexSearcher"/> and
            <see cref="T:Lucene.Net.Facet.Taxonomy.TaxonomyReader"/> 
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.Taxonomy.SearcherTaxonomyManager.SearcherAndTaxonomy.Searcher">
            <summary>
            Point-in-time <see cref="T:Lucene.Net.Search.IndexSearcher"/>.
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.Taxonomy.SearcherTaxonomyManager.SearcherAndTaxonomy.TaxonomyReader">
            <summary>
            Matching point-in-time <see cref="T:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyReader"/>.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.SearcherTaxonomyManager.SearcherAndTaxonomy.#ctor(Lucene.Net.Search.IndexSearcher,Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyReader)">
            <summary>
            Create a <see cref="T:Lucene.Net.Facet.Taxonomy.SearcherTaxonomyManager.SearcherAndTaxonomy"/>
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.SearcherTaxonomyManager.#ctor(Lucene.Net.Index.IndexWriter,System.Boolean,Lucene.Net.Search.SearcherFactory,Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter)">
            <summary>
            Creates near-real-time searcher and taxonomy reader
            from the corresponding writers. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.SearcherTaxonomyManager.#ctor(Lucene.Net.Store.Directory,Lucene.Net.Store.Directory,Lucene.Net.Search.SearcherFactory)">
            <summary>
            Creates search and taxonomy readers over the corresponding directories.
            
            <para>
            <b>NOTE:</b> you should only use this constructor if you commit and call
            <see cref="M:Lucene.Net.Search.ReferenceManager`1.MaybeRefresh"/> (on the <see cref="T:Lucene.Net.Index.ReaderManager"/>) in the same thread. Otherwise it could lead to an
            unsync'd <see cref="T:Lucene.Net.Search.IndexSearcher"/> and <see cref="T:Lucene.Net.Facet.Taxonomy.TaxonomyReader"/> pair.
            </para>
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.Taxonomy.TaxonomyFacetCounts">
            <summary>
            Reads from any <see cref="T:Lucene.Net.Facet.Taxonomy.OrdinalsReader"/>; use <see cref="T:Lucene.Net.Facet.Taxonomy.FastTaxonomyFacetCounts"/>
            if you are using the default encoding from <see cref="T:Lucene.Net.Index.BinaryDocValues"/>.
            
            @lucene.experimental 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.TaxonomyFacetCounts.#ctor(Lucene.Net.Facet.Taxonomy.OrdinalsReader,Lucene.Net.Facet.Taxonomy.TaxonomyReader,Lucene.Net.Facet.FacetsConfig,Lucene.Net.Facet.FacetsCollector)">
            <summary>
            Create <see cref="T:Lucene.Net.Facet.Taxonomy.TaxonomyFacetCounts"/>, which also
            counts all facet labels.  Use this for a non-default
            <see cref="T:Lucene.Net.Facet.Taxonomy.OrdinalsReader"/>; otherwise use <see cref="T:Lucene.Net.Facet.Taxonomy.FastTaxonomyFacetCounts"/>. 
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.Taxonomy.TaxonomyFacets">
            <summary>
            Base class for all taxonomy-based facets impls.
            </summary>
        </member>
        <member name="F:Lucene.Net.Facet.Taxonomy.TaxonomyFacets.m_indexFieldName">
            <summary>
            Index field name provided to the constructor.
            </summary>
        </member>
        <member name="F:Lucene.Net.Facet.Taxonomy.TaxonomyFacets.m_taxoReader">
            <summary>
            <see cref="T:Lucene.Net.Facet.Taxonomy.TaxonomyReader"/> provided to the constructor.
            </summary>
        </member>
        <member name="F:Lucene.Net.Facet.Taxonomy.TaxonomyFacets.m_config">
            <summary>
            <see cref="T:Lucene.Net.Facet.FacetsConfig"/> provided to the constructor.
            </summary>
        </member>
        <member name="F:Lucene.Net.Facet.Taxonomy.TaxonomyFacets.m_children">
            <summary>
            Maps parent ordinal to its child, or -1 if the parent
            is childless. 
            </summary>
        </member>
        <member name="F:Lucene.Net.Facet.Taxonomy.TaxonomyFacets.m_siblings">
            <summary>
            Maps an ordinal to its sibling, or -1 if there is no
            sibling. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.TaxonomyFacets.#ctor(System.String,Lucene.Net.Facet.Taxonomy.TaxonomyReader,Lucene.Net.Facet.FacetsConfig)">
            <summary>
            Sole constructor. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.TaxonomyFacets.VerifyDim(System.String)">
            <summary>
            Throws <see cref="T:System.ArgumentException"/> if the
            dimension is not recognized.  Otherwise, returns the
            <see cref="T:Lucene.Net.Facet.FacetsConfig.DimConfig"/> for this dimension. 
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.Taxonomy.TaxonomyFacetSumSingleAssociations">
            <summary>
            Aggregates sum of <see cref="T:System.Single"/> values previously indexed with
            <see cref="T:Lucene.Net.Facet.Taxonomy.SingleAssociationFacetField"/>, assuming the default
            encoding.
            <para/>
            NOTE: This was TaxonomyFacetSumFloatAssociations in Lucene
            
            @lucene.experimental 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.TaxonomyFacetSumSingleAssociations.#ctor(Lucene.Net.Facet.Taxonomy.TaxonomyReader,Lucene.Net.Facet.FacetsConfig,Lucene.Net.Facet.FacetsCollector)">
            <summary>
            Create <see cref="T:Lucene.Net.Facet.Taxonomy.TaxonomyFacetSumSingleAssociations"/> against
            the default index field. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.TaxonomyFacetSumSingleAssociations.#ctor(System.String,Lucene.Net.Facet.Taxonomy.TaxonomyReader,Lucene.Net.Facet.FacetsConfig,Lucene.Net.Facet.FacetsCollector)">
            <summary>
            Create <see cref="T:Lucene.Net.Facet.Taxonomy.TaxonomyFacetSumSingleAssociations"/> against
            the specified index field. 
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.Taxonomy.TaxonomyFacetSumInt32Associations">
            <summary>
            Aggregates sum of <see cref="T:System.Int32"/> values previously indexed with
            <see cref="T:Lucene.Net.Facet.Taxonomy.Int32AssociationFacetField"/>, assuming the default
            encoding.
            <para/>
            NOTE: This was TaxonomyFacetSumIntAssociations in Lucene
            
            @lucene.experimental 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.TaxonomyFacetSumInt32Associations.#ctor(Lucene.Net.Facet.Taxonomy.TaxonomyReader,Lucene.Net.Facet.FacetsConfig,Lucene.Net.Facet.FacetsCollector)">
            <summary>
            Create <see cref="T:Lucene.Net.Facet.Taxonomy.TaxonomyFacetSumInt32Associations"/> against
            the default index field. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.TaxonomyFacetSumInt32Associations.#ctor(System.String,Lucene.Net.Facet.Taxonomy.TaxonomyReader,Lucene.Net.Facet.FacetsConfig,Lucene.Net.Facet.FacetsCollector)">
            <summary>
            Create <see cref="T:Lucene.Net.Facet.Taxonomy.TaxonomyFacetSumInt32Associations"/> against
            the specified index field. 
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.Taxonomy.TaxonomyFacetSumValueSource">
            <summary>
            Aggregates sum of values from <see cref="M:Lucene.Net.Queries.Function.FunctionValues.DoubleVal(System.Int32)"/> and <see cref="M:Lucene.Net.Queries.Function.FunctionValues.DoubleVal(System.Int32,System.Double[])"/>, 
            for each facet label.
            
            @lucene.experimental 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.TaxonomyFacetSumValueSource.#ctor(Lucene.Net.Facet.Taxonomy.TaxonomyReader,Lucene.Net.Facet.FacetsConfig,Lucene.Net.Facet.FacetsCollector,Lucene.Net.Queries.Function.ValueSource)">
            <summary>
            Aggreggates float facet values from the provided
            <see cref="T:Lucene.Net.Queries.Function.ValueSource"/>, pulling ordinals using <see cref="T:Lucene.Net.Facet.Taxonomy.DocValuesOrdinalsReader"/>
            against the default indexed
            facet field <see cref="F:Lucene.Net.Facet.FacetsConfig.DEFAULT_INDEX_FIELD_NAME"/>. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.TaxonomyFacetSumValueSource.#ctor(Lucene.Net.Facet.Taxonomy.OrdinalsReader,Lucene.Net.Facet.Taxonomy.TaxonomyReader,Lucene.Net.Facet.FacetsConfig,Lucene.Net.Facet.FacetsCollector,Lucene.Net.Queries.Function.ValueSource)">
            <summary>
            Aggreggates float facet values from the provided
            <see cref="T:Lucene.Net.Queries.Function.ValueSource"/>, and pulls ordinals from the
            provided <see cref="T:Lucene.Net.Facet.Taxonomy.OrdinalsReader"/>. 
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.Taxonomy.TaxonomyFacetSumValueSource.ScoreValueSource">
            <summary>
            <see cref="T:Lucene.Net.Queries.Function.ValueSource"/> that returns the score for each
            hit; use this to aggregate the sum of all hit scores
            for each facet label.  
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.TaxonomyFacetSumValueSource.ScoreValueSource.#ctor">
            <summary>
            Sole constructor.
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.Taxonomy.TaxonomyReader">
            <summary>
            TaxonomyReader is the read-only interface with which the faceted-search
            library uses the taxonomy during search time.
            <para>
            A TaxonomyReader holds a list of categories. Each category has a serial
            number which we call an "ordinal", and a hierarchical "path" name:
            <list type="bullet">
            <item><description>
            The ordinal is an integer that starts at 0 for the first category (which is
            always the root category), and grows contiguously as more categories are
            added; Note that once a category is added, it can never be deleted.
            </description></item>
            <item><description>
            The path is a CategoryPath object specifying the category's position in the
            hierarchy.
            </description></item>
            </list>
            </para>
            <b>Notes about concurrent access to the taxonomy:</b>
            <para>
            An implementation must allow multiple readers to be active concurrently
            with a single writer. Readers follow so-called "point in time" semantics,
            i.e., a TaxonomyReader object will only see taxonomy entries which were
            available at the time it was created. What the writer writes is only
            available to (new) readers after the writer's <see cref="M:Lucene.Net.Index.IndexWriter.Commit"/> is called.
            </para>
            <para>
            In faceted search, two separate indices are used: the main Lucene index,
            and the taxonomy. Because the main index refers to the categories listed
            in the taxonomy, it is important to open the taxonomy *after* opening the
            main index, and it is also necessary to Reopen() the taxonomy after
            Reopen()ing the main index.
            </para>
            <para>
            This order is important, otherwise it would be possible for the main index
            to refer to a category which is not yet visible in the old snapshot of
            the taxonomy. Note that it is indeed fine for the the taxonomy to be opened
            after the main index - even a long time after. The reason is that once
            a category is added to the taxonomy, it can never be changed or deleted,
            so there is no danger that a "too new" taxonomy not being consistent with
            an older index.
            </para>
            
            @lucene.experimental
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.Taxonomy.TaxonomyReader.ChildrenEnumerator">
            <summary>
            An iterator over a category's children.
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.Taxonomy.TaxonomyReader.ChildrenEnumerator.Current">
            <summary>
            Gets the current child. Returns <see cref="F:Lucene.Net.Facet.Taxonomy.TaxonomyReader.INVALID_ORDINAL"/> if
            positioned before the first child or after the last child.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.TaxonomyReader.ChildrenEnumerator.MoveNext">
            <summary>
            Move to the next child ordinal. Returns <c>false</c> if there are no more children.
            </summary>
            <returns></returns>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.TaxonomyReader.#ctor">
            <summary>
            Sole constructor.
            </summary>
        </member>
        <member name="F:Lucene.Net.Facet.Taxonomy.TaxonomyReader.ROOT_ORDINAL">
            <summary>
            The root category (the category with the empty path) always has the ordinal
            0, to which we give a name ROOT_ORDINAL. <see cref="M:Lucene.Net.Facet.Taxonomy.TaxonomyReader.GetOrdinal(Lucene.Net.Facet.Taxonomy.FacetLabel)"/>
            of an empty path will always return <see cref="F:Lucene.Net.Facet.Taxonomy.TaxonomyReader.ROOT_ORDINAL"/>, and
            <see cref="M:Lucene.Net.Facet.Taxonomy.TaxonomyReader.GetPath(System.Int32)"/> with <see cref="F:Lucene.Net.Facet.Taxonomy.TaxonomyReader.ROOT_ORDINAL"/> will return the empty path.
            </summary>
        </member>
        <member name="F:Lucene.Net.Facet.Taxonomy.TaxonomyReader.INVALID_ORDINAL">
            <summary>
            Ordinals are always non-negative, so a negative ordinal can be used to
            signify an error. Methods here return <see cref="F:Lucene.Net.Facet.Taxonomy.TaxonomyReader.INVALID_ORDINAL"/> (-1) in this case.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.TaxonomyReader.OpenIfChanged``1(``0)">
            <summary>
            If the taxonomy has changed since the provided reader was opened, open and
            return a new <see cref="T:Lucene.Net.Facet.Taxonomy.TaxonomyReader"/>; else, return <c>null</c>. The new
            reader, if not <c>null</c>, will be the same type of reader as the one
            given to this method.
            
            <para>
            This method is typically far less costly than opening a fully new
            <see cref="T:Lucene.Net.Facet.Taxonomy.TaxonomyReader"/> as it shares resources with the provided
            <see cref="T:Lucene.Net.Facet.Taxonomy.TaxonomyReader"/>, when possible.
            </para>
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.TaxonomyReader.DoOpenIfChanged">
            <summary>
            Implements the actual opening of a new <see cref="T:Lucene.Net.Facet.Taxonomy.TaxonomyReader"/> instance if
            the taxonomy has changed.
            </summary>
            <seealso cref="M:Lucene.Net.Facet.Taxonomy.TaxonomyReader.OpenIfChanged``1(``0)"/>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.TaxonomyReader.EnsureOpen">
            <summary>
            Throws <see cref="T:System.ObjectDisposedException"/> if this <see cref="T:Lucene.Net.Index.IndexReader"/> is disposed
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.TaxonomyReader.Dispose(System.Boolean)">
            <summary>
            Performs the actual task of closing the resources that are used by the
            taxonomy reader.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.TaxonomyReader.DecRef">
            <summary>
            Expert: decreases the refCount of this TaxonomyReader instance. If the
            refCount drops to 0 this taxonomy reader is closed.
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.Taxonomy.TaxonomyReader.ParallelTaxonomyArrays">
            <summary>
            Returns a <see cref="P:Lucene.Net.Facet.Taxonomy.TaxonomyReader.ParallelTaxonomyArrays"/> object which can be used to
            efficiently traverse the taxonomy tree.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.TaxonomyReader.GetChildren(System.Int32)">
            <summary>
            Returns an iterator over the children of the given ordinal.
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.Taxonomy.TaxonomyReader.CommitUserData">
            <summary>
            Retrieve user committed data.
            </summary>
            <seealso cref="P:Lucene.Net.Facet.Taxonomy.ITaxonomyWriter.CommitData"/>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.TaxonomyReader.GetOrdinal(Lucene.Net.Facet.Taxonomy.FacetLabel)">
            <summary>
            Returns the ordinal of the category given as a path. The ordinal is the
            category's serial number, an integer which starts with 0 and grows as more
            categories are added (note that once a category is added, it can never be
            deleted).
            </summary>
            <returns> the category's ordinal or <see cref="F:Lucene.Net.Facet.Taxonomy.TaxonomyReader.INVALID_ORDINAL"/> if the category
                    wasn't found. </returns>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.TaxonomyReader.GetOrdinal(System.String,System.String[])">
            <summary>
            Returns ordinal for the dim + path.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.TaxonomyReader.GetPath(System.Int32)">
            <summary>
            Returns the path name of the category with the given ordinal.
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.Taxonomy.TaxonomyReader.RefCount">
            <summary>
            Returns the current refCount for this taxonomy reader.
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.Taxonomy.TaxonomyReader.Count">
            <summary>
            Returns the number of categories in the taxonomy. Note that the number of
            categories returned is often slightly higher than the number of categories
            inserted into the taxonomy; This is because when a category is added to the
            taxonomy, its ancestors are also added automatically (including the root,
            which always get ordinal 0).
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.TaxonomyReader.IncRef">
            <summary>
            Expert: increments the refCount of this TaxonomyReader instance. RefCounts
            can be used to determine when a taxonomy reader can be closed safely, i.e.
            as soon as there are no more references. Be sure to always call a
            corresponding <see cref="M:Lucene.Net.Facet.Taxonomy.TaxonomyReader.DecRef"/>, in a finally clause; otherwise the reader may never
            be disposed.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.TaxonomyReader.TryIncRef">
            <summary>
            Expert: increments the refCount of this TaxonomyReader
            instance only if it has not been closed yet.  Returns
            <c>true</c> on success. 
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.Taxonomy.ITaxonomyWriter">
            <summary>
            <see cref="T:Lucene.Net.Facet.Taxonomy.ITaxonomyWriter"/> is the interface which the faceted-search library uses
            to dynamically build the taxonomy at indexing time.
            <para>
            Notes about concurrent access to the taxonomy:
            </para>
            <para>
            An implementation must allow multiple readers and a single writer to be
            active concurrently. Readers follow so-called "point in time" semantics,
            i.e., a reader object will only see taxonomy entries which were available
            at the time it was created. What the writer writes is only available to
            (new) readers after the writer's <see cref="M:Lucene.Net.Index.IndexWriter.Commit"/> is called.
            </para>
            <para>
            Faceted search keeps two indices - namely Lucene's main index, and this
            taxonomy index. When one or more readers are active concurrently with the
            writer, care must be taken to avoid an inconsistency between the state of
            these two indices: When writing to the indices, the taxonomy must always
            be committed to disk *before* the main index, because the main index
            refers to categories listed in the taxonomy.
            Such control can best be achieved by turning off the main index's
            "autocommit" feature, and explicitly calling <see cref="M:Lucene.Net.Index.IndexWriter.Commit"/> for both indices
            (first for the taxonomy, then for the main index).
            In old versions of Lucene (2.2 or earlier), when autocommit could not be
            turned off, a more complicated solution needs to be used. E.g., use
            some sort of (possibly inter-process) locking to ensure that a reader
            is being opened only right after both indices have been flushed (and
            before anything else is written to them).
            </para>
            
            @lucene.experimental
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.ITaxonomyWriter.AddCategory(Lucene.Net.Facet.Taxonomy.FacetLabel)">
            <summary>
            <see cref="M:Lucene.Net.Facet.Taxonomy.ITaxonomyWriter.AddCategory(Lucene.Net.Facet.Taxonomy.FacetLabel)"/> adds a category with a given path name to the taxonomy,
            and returns its ordinal. If the category was already present in
            the taxonomy, its existing ordinal is returned.
            <para/>
            Before adding a category, <see cref="M:Lucene.Net.Facet.Taxonomy.ITaxonomyWriter.AddCategory(Lucene.Net.Facet.Taxonomy.FacetLabel)"/> makes sure that all its
            ancestor categories exist in the taxonomy as well. As result, the
            ordinal of a category is guaranteed to be smaller then the ordinal of
            any of its descendants. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.ITaxonomyWriter.GetParent(System.Int32)">
            <summary>
            <see cref="M:Lucene.Net.Facet.Taxonomy.ITaxonomyWriter.GetParent(System.Int32)"/> returns the ordinal of the parent category of the category
            with the given ordinal.
            <para>
            When a category is specified as a path name, finding the path of its
            parent is as trivial as dropping the last component of the path.
            <see cref="M:Lucene.Net.Facet.Taxonomy.ITaxonomyWriter.GetParent(System.Int32)"/> is functionally equivalent to calling <see cref="M:Lucene.Net.Facet.Taxonomy.TaxonomyReader.GetPath(System.Int32)"/> on the
            given ordinal, dropping the last component of the path, and then calling
            <see cref="M:Lucene.Net.Facet.Taxonomy.TaxonomyReader.GetOrdinal(Lucene.Net.Facet.Taxonomy.FacetLabel)"/> to get an ordinal back.
            </para>
            <para>
            If the given ordinal is the <see cref="F:Lucene.Net.Facet.Taxonomy.TaxonomyReader.ROOT_ORDINAL"/>, an 
            <see cref="F:Lucene.Net.Facet.Taxonomy.TaxonomyReader.INVALID_ORDINAL"/> is returned.
            If the given ordinal is a top-level category, the 
            <see cref="F:Lucene.Net.Facet.Taxonomy.TaxonomyReader.ROOT_ORDINAL"/> is returned.
            If an invalid ordinal is given (negative or beyond the last available
            ordinal), an <see cref="T:System.ArgumentOutOfRangeException"/> is thrown. However, it is
            expected that <see cref="M:Lucene.Net.Facet.Taxonomy.ITaxonomyWriter.GetParent(System.Int32)"/> will only be called for ordinals which are
            already known to be in the taxonomy.
            </para>
            <para>
            TODO (Facet): instead of a <see cref="M:Lucene.Net.Facet.Taxonomy.ITaxonomyWriter.GetParent(System.Int32)">GetParent(ordinal)</see> method, consider having a
            GetCategory(categorypath, prefixlen) which is similar to <see cref="M:Lucene.Net.Facet.Taxonomy.ITaxonomyWriter.AddCategory(Lucene.Net.Facet.Taxonomy.FacetLabel)"/>
            except it doesn't add new categories; This method can be used to get
            the ordinals of all prefixes of the given category, and it can use
            exactly the same code and cache used by <see cref="M:Lucene.Net.Facet.Taxonomy.ITaxonomyWriter.AddCategory(Lucene.Net.Facet.Taxonomy.FacetLabel)"/> so it means less code.
            </para>
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.Taxonomy.ITaxonomyWriter.Count">
            <summary>
            <see cref="P:Lucene.Net.Facet.Taxonomy.ITaxonomyWriter.Count"/> returns the number of categories in the taxonomy.
            <para/>
            Because categories are numbered consecutively starting with 0, it
            means the taxonomy contains ordinals 0 through <see cref="P:Lucene.Net.Facet.Taxonomy.ITaxonomyWriter.Count"/>-1.
            <para/>
            Note that the number returned by <see cref="P:Lucene.Net.Facet.Taxonomy.ITaxonomyWriter.Count"/> is often slightly higher
            than the number of categories inserted into the taxonomy; This is
            because when a category is added to the taxonomy, its ancestors
            are also added automatically (including the root, which always get
            ordinal 0).
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.ITaxonomyWriter.SetCommitData(System.Collections.Generic.IDictionary{System.String,System.String})">
            <summary>
            Sets the commit user data map. That method is considered a transaction and
            will be committed (<see cref="M:Lucene.Net.Index.IndexWriter.Commit"/>) even if no other changes were made to
            the writer instance.
            <para>
            <b>NOTE:</b> the map is cloned internally, therefore altering the map's
            contents after calling this method has no effect.
            </para>
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.Taxonomy.ITaxonomyWriter.CommitData">
            <summary>
            Returns the commit user data map that was set on
            <see cref="M:Lucene.Net.Facet.Taxonomy.ITaxonomyWriter.SetCommitData(System.Collections.Generic.IDictionary{System.String,System.String})"/>.
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.Taxonomy.WriterCache.CategoryPathUtils">
            <summary>
            Utilities for use of <see cref="T:Lucene.Net.Facet.Taxonomy.FacetLabel"/> by <see cref="T:Lucene.Net.Facet.Taxonomy.WriterCache.CompactLabelToOrdinal"/>.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.WriterCache.CategoryPathUtils.Serialize(Lucene.Net.Facet.Taxonomy.FacetLabel,Lucene.Net.Facet.Taxonomy.WriterCache.CharBlockArray)">
            <summary>
            Serializes the given <see cref="T:Lucene.Net.Facet.Taxonomy.FacetLabel"/> to the <see cref="T:Lucene.Net.Facet.Taxonomy.WriterCache.CharBlockArray"/>.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.WriterCache.CategoryPathUtils.HashCodeOfSerialized(Lucene.Net.Facet.Taxonomy.WriterCache.CharBlockArray,System.Int32)">
            <summary>
            Calculates a hash function of a path that was serialized with
            <see cref="M:Lucene.Net.Facet.Taxonomy.WriterCache.CategoryPathUtils.Serialize(Lucene.Net.Facet.Taxonomy.FacetLabel,Lucene.Net.Facet.Taxonomy.WriterCache.CharBlockArray)"/>.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.WriterCache.CategoryPathUtils.EqualsToSerialized(Lucene.Net.Facet.Taxonomy.FacetLabel,Lucene.Net.Facet.Taxonomy.WriterCache.CharBlockArray,System.Int32)">
            <summary>
            Check whether the <see cref="T:Lucene.Net.Facet.Taxonomy.FacetLabel"/> is equal to the one serialized in
            <see cref="T:Lucene.Net.Facet.Taxonomy.WriterCache.CharBlockArray"/>.
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.Taxonomy.WriterCache.CharBlockArray">
            <summary>
            Similar to <see cref="T:System.Text.StringBuilder"/>, but with a more efficient growing strategy.
            This class uses char array blocks to grow.
            <para/>
            @lucene.experimental
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.WriterCache.CharBlockArray.Equals(System.Int32,System.Int32,System.ReadOnlySpan{System.Char})">
            <summary>
            Compares a slice of this <see cref="T:Lucene.Net.Facet.Taxonomy.WriterCache.CharBlockArray"/> to <paramref name="other"/>
            for binary (ordinal) equality. Does not allocate any memory.
            <para/>
            LUCENENET specific.
            </summary>
            <param name="startIndex">The start index of this <see cref="T:Lucene.Net.Facet.Taxonomy.WriterCache.CharBlockArray"/>.</param>
            <param name="length">The length of characters to compare.</param>
            <param name="other">The other character sequence to check for equality.</param>
            <returns><c>true</c> if the two character sequences are equal; otherwise <c>false</c></returns>
        </member>
        <member name="T:Lucene.Net.Facet.Taxonomy.WriterCache.Cl2oTaxonomyWriterCache">
            <summary>
            <see cref="T:Lucene.Net.Facet.Taxonomy.WriterCache.ITaxonomyWriterCache"/> using <see cref="T:Lucene.Net.Facet.Taxonomy.WriterCache.CompactLabelToOrdinal"/>. Although
            called cache, it maintains in memory all the mappings from category to
            ordinal, relying on that <see cref="T:Lucene.Net.Facet.Taxonomy.WriterCache.CompactLabelToOrdinal"/> is an efficient
            mapping for this purpose.
            
            @lucene.experimental
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.WriterCache.Cl2oTaxonomyWriterCache.#ctor(System.Int32,System.Single,System.Int32)">
            <summary>
            Sole constructor.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.WriterCache.Cl2oTaxonomyWriterCache.GetMemoryUsage">
            <summary>
            Returns the number of bytes in memory used by this object.
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.Taxonomy.WriterCache.CollisionMap">
            <summary>
            HashMap to store colliding labels. See <see cref="T:Lucene.Net.Facet.Taxonomy.WriterCache.CompactLabelToOrdinal"/> for
            details.
            
            @lucene.experimental
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.Taxonomy.WriterCache.CollisionMap.Count">
            <summary>
            How many mappings.
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.Taxonomy.WriterCache.CollisionMap.Capacity">
            <summary>
            How many slots are allocated. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.WriterCache.CollisionMap.Get(Lucene.Net.Facet.Taxonomy.FacetLabel,System.Int32)">
            <summary>
            Return the mapping, or <see cref="F:Lucene.Net.Facet.Taxonomy.WriterCache.LabelToOrdinal.INVALID_ORDINAL"/> 
            if the label isn't recognized. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.WriterCache.CollisionMap.AddLabel(Lucene.Net.Facet.Taxonomy.FacetLabel,System.Int32,System.Int32)">
            <summary>
            Add another mapping. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.WriterCache.CollisionMap.AddLabelOffset(System.Int32,System.Int32,System.Int32)">
            <summary>
            This method does not check if the same value is already in the map because
            we pass in an char-array offset, so so we now that we're in resize-mode
            here.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.WriterCache.CollisionMap.IndexFor(System.Int32,System.Int32)">
            <summary>
            Returns index for hash code h. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.WriterCache.CollisionMap.GetMemoryUsage">
            <summary>
            Returns an estimate of the memory usage of this CollisionMap. </summary>
            <returns> The approximate number of bytes used by this structure. </returns>
        </member>
        <member name="T:Lucene.Net.Facet.Taxonomy.WriterCache.CompactLabelToOrdinal">
            <summary>
            This is a very efficient <see cref="T:Lucene.Net.Facet.Taxonomy.WriterCache.LabelToOrdinal"/> implementation that uses a
            <see cref="T:Lucene.Net.Facet.Taxonomy.WriterCache.CharBlockArray"/> to store all labels and a configurable number of <see cref="T:Lucene.Net.Facet.Taxonomy.WriterCache.CompactLabelToOrdinal.HashArray"/>s to
            reference the labels.
            <para>
            Since the <see cref="T:Lucene.Net.Facet.Taxonomy.WriterCache.CompactLabelToOrdinal.HashArray"/>s don't handle collisions, a <see cref="T:Lucene.Net.Facet.Taxonomy.WriterCache.CollisionMap"/> is used
            to store the colliding labels.
            </para>
            <para>
            This data structure grows by adding a new HashArray whenever the number of
            collisions in the <see cref="T:Lucene.Net.Facet.Taxonomy.WriterCache.CollisionMap"/> exceeds <see cref="F:Lucene.Net.Facet.Taxonomy.WriterCache.CompactLabelToOrdinal.loadFactor"/>
            <c>GetMaxOrdinal().</c> Growing also includes reinserting all colliding
            labels into the <see cref="T:Lucene.Net.Facet.Taxonomy.WriterCache.CompactLabelToOrdinal.HashArray"/>s to possibly reduce the number of collisions.
            
            For setting the <see cref="F:Lucene.Net.Facet.Taxonomy.WriterCache.CompactLabelToOrdinal.loadFactor"/> see 
            <see cref="M:Lucene.Net.Facet.Taxonomy.WriterCache.CompactLabelToOrdinal.#ctor(System.Int32,System.Single,System.Int32)"/>. 
            </para>
            <para>
            This data structure has a much lower memory footprint (~30%) compared to a
            Java HashMap&lt;String, Integer&gt;. It also only uses a small fraction of objects
            a HashMap would use, thus limiting the GC overhead. Ingestion speed was also
            ~50% faster compared to a HashMap for 3M unique labels.
            
            @lucene.experimental
            </para>
            </summary>
        </member>
        <member name="F:Lucene.Net.Facet.Taxonomy.WriterCache.CompactLabelToOrdinal.DefaultLoadFactor">
            <summary>
            Default maximum load factor. </summary>
        </member>
        <member name="P:Lucene.Net.Facet.Taxonomy.WriterCache.CompactLabelToOrdinal.SizeOfMap">
            <summary>
            How many labels. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.WriterCache.CompactLabelToOrdinal.#ctor(System.Int32,System.Single,System.Int32)">
            <summary>
            Sole constructor.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.WriterCache.CompactLabelToOrdinal.IndexFor(System.Int32,System.Int32)">
            <summary>
            Returns index for hash code h.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.WriterCache.CompactLabelToOrdinal.GetMemoryUsage">
            <summary>
            Returns an estimate of the amount of memory used by this table. Called only in
            this package. Memory is consumed mainly by three structures: the hash arrays,
            label repository and collision map.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.WriterCache.CompactLabelToOrdinal.Open(System.IO.FileInfo,System.Single,System.Int32)">
            <summary>
            Opens the file and reloads the CompactLabelToOrdinal. The file it expects
            is generated from the <see cref="M:Lucene.Net.Facet.Taxonomy.WriterCache.CompactLabelToOrdinal.Flush(System.IO.Stream)"/> command.
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.Taxonomy.WriterCache.LabelToOrdinal">
            <summary>
            Abstract class for storing Label->Ordinal mappings in a taxonomy. 
            <para/>
            @lucene.experimental
            </summary>
        </member>
        <member name="F:Lucene.Net.Facet.Taxonomy.WriterCache.LabelToOrdinal.m_counter">
            <summary>
            How many ordinals we've seen. </summary>
        </member>
        <member name="F:Lucene.Net.Facet.Taxonomy.WriterCache.LabelToOrdinal.INVALID_ORDINAL">
            <summary>
            Returned by <see cref="M:Lucene.Net.Facet.Taxonomy.WriterCache.LabelToOrdinal.GetOrdinal(Lucene.Net.Facet.Taxonomy.FacetLabel)"/> when the label isn't
            recognized. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.WriterCache.LabelToOrdinal.#ctor">
            <summary>
            Default constructor.
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.Taxonomy.WriterCache.LabelToOrdinal.MaxOrdinal">
            <summary>
            return the maximal Ordinal assigned so far
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.WriterCache.LabelToOrdinal.GetNextOrdinal">
            <summary>
            Returns the next unassigned ordinal. The default behavior of this method
            is to simply increment a counter.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.WriterCache.LabelToOrdinal.AddLabel(Lucene.Net.Facet.Taxonomy.FacetLabel,System.Int32)">
            <summary>
            Adds a new label if its not yet in the table.
            Throws an <see cref="T:System.ArgumentException"/> if the same label with
            a different ordinal was previoulsy added to this table.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.WriterCache.LabelToOrdinal.GetOrdinal(Lucene.Net.Facet.Taxonomy.FacetLabel)">
            <summary>
            Returns the ordinal assigned to the given label, 
            or <see cref="F:Lucene.Net.Facet.Taxonomy.WriterCache.LabelToOrdinal.INVALID_ORDINAL"/> if the label cannot be found in this table.
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.Taxonomy.WriterCache.LruTaxonomyWriterCache">
            <summary>
            LRU <see cref="T:Lucene.Net.Facet.Taxonomy.WriterCache.ITaxonomyWriterCache"/> - good choice for huge taxonomies.
            <para/>
            @lucene.experimental
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.Taxonomy.WriterCache.LruTaxonomyWriterCache.LRUType">
            <summary>
            Determines cache type.
            For guaranteed correctness - not relying on no-collisions in the hash
            function, LRU_STRING should be used.
            </summary>
        </member>
        <member name="F:Lucene.Net.Facet.Taxonomy.WriterCache.LruTaxonomyWriterCache.LRUType.LRU_HASHED">
            <summary>
            Use the label's hash as the key; this can lead to
             silent conflicts! 
            </summary>
        </member>
        <member name="F:Lucene.Net.Facet.Taxonomy.WriterCache.LruTaxonomyWriterCache.LRUType.LRU_STRING">
            <summary>
            Use the label as the hash key; this is always
             correct but will usually use more RAM. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.WriterCache.LruTaxonomyWriterCache.#ctor(System.Int32)">
            <summary>
            Creates this with <see cref="F:Lucene.Net.Facet.Taxonomy.WriterCache.LruTaxonomyWriterCache.LRUType.LRU_HASHED"/> method.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.WriterCache.LruTaxonomyWriterCache.#ctor(System.Int32,Lucene.Net.Facet.Taxonomy.WriterCache.LruTaxonomyWriterCache.LRUType)">
            <summary>
            Creates this with the specified method.
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.Taxonomy.WriterCache.NameHashInt32CacheLru">
            <summary>
            An an LRU cache of mapping from name to int.
            Used to cache Ordinals of category paths.
            It uses as key, hash of the path instead of the path.
            This way the cache takes less RAM, but correctness depends on
            assuming no collisions.
            <para/>
            NOTE: this was NameHashIntCacheLRU in Lucene
            <para/>
            @lucene.experimental
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.Taxonomy.WriterCache.NameHashInt32CacheLru.Count">
            <inheritdoc/>
        </member>
        <member name="P:Lucene.Net.Facet.Taxonomy.WriterCache.NameHashInt32CacheLru.Limit">
            <inheritdoc/>
        </member>
        <member name="P:Lucene.Net.Facet.Taxonomy.WriterCache.NameHashInt32CacheLru.Lucene#Net#Facet#Taxonomy#WriterCache#IInternalNameInt32CacheLru#Stats">
            <inheritdoc/>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.WriterCache.NameHashInt32CacheLru.Lucene#Net#Facet#Taxonomy#WriterCache#IInternalNameInt32CacheLru#Clear">
            <inheritdoc/>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.WriterCache.NameHashInt32CacheLru.Lucene#Net#Facet#Taxonomy#WriterCache#IInternalNameInt32CacheLru#MakeRoomLRU">
            <inheritdoc/>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.WriterCache.NameHashInt32CacheLru.Lucene#Net#Facet#Taxonomy#WriterCache#IInternalNameInt32CacheLru#Put(Lucene.Net.Facet.Taxonomy.FacetLabel,System.Int32)">
            <inheritdoc/>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.WriterCache.NameHashInt32CacheLru.Lucene#Net#Facet#Taxonomy#WriterCache#IInternalNameInt32CacheLru#Put(Lucene.Net.Facet.Taxonomy.FacetLabel,System.Int32,System.Int32)">
            <inheritdoc/>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.WriterCache.NameHashInt32CacheLru.Lucene#Net#Facet#Taxonomy#WriterCache#IInternalNameInt32CacheLru#TryGetValue(Lucene.Net.Facet.Taxonomy.FacetLabel,System.Int32@)">
            <inheritdoc/>
        </member>
        <member name="T:Lucene.Net.Facet.Taxonomy.WriterCache.NameInt32CacheLru">
            <summary>
            An an LRU cache of mapping from name to int.
            Used to cache Ordinals of category paths.
            <para/>
            NOTE: This was NameIntCacheLRU in Lucene
            <para/>
            @lucene.experimental
            </summary>
            <remarks>
            Note: Nothing in this class is synchronized. The caller is assumed to be
            synchronized so that no two methods of this class are called concurrently.
            </remarks>
        </member>
        <member name="P:Lucene.Net.Facet.Taxonomy.WriterCache.NameInt32CacheLru.Count">
            <inheritdoc/>
        </member>
        <member name="P:Lucene.Net.Facet.Taxonomy.WriterCache.NameInt32CacheLru.Limit">
            <inheritdoc/>
        </member>
        <member name="P:Lucene.Net.Facet.Taxonomy.WriterCache.NameInt32CacheLru.Lucene#Net#Facet#Taxonomy#WriterCache#IInternalNameInt32CacheLru#Stats">
            <inheritdoc/>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.WriterCache.NameInt32CacheLru.Lucene#Net#Facet#Taxonomy#WriterCache#IInternalNameInt32CacheLru#Clear">
            <inheritdoc/>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.WriterCache.NameInt32CacheLru.Lucene#Net#Facet#Taxonomy#WriterCache#IInternalNameInt32CacheLru#MakeRoomLRU">
            <inheritdoc/>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.WriterCache.NameInt32CacheLru.Lucene#Net#Facet#Taxonomy#WriterCache#IInternalNameInt32CacheLru#Put(Lucene.Net.Facet.Taxonomy.FacetLabel,System.Int32)">
            <inheritdoc/>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.WriterCache.NameInt32CacheLru.Lucene#Net#Facet#Taxonomy#WriterCache#IInternalNameInt32CacheLru#Put(Lucene.Net.Facet.Taxonomy.FacetLabel,System.Int32,System.Int32)">
            <inheritdoc/>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.WriterCache.NameInt32CacheLru.Lucene#Net#Facet#Taxonomy#WriterCache#IInternalNameInt32CacheLru#TryGetValue(Lucene.Net.Facet.Taxonomy.FacetLabel,System.Int32@)">
            <inheritdoc/>
        </member>
        <member name="T:Lucene.Net.Facet.Taxonomy.WriterCache.INameInt32CacheLru">
            <summary>
            Public members of the <see cref="T:Lucene.Net.Facet.Taxonomy.WriterCache.NameInt32CacheLru"/> that are shared between instances.
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.Taxonomy.WriterCache.INameInt32CacheLru.Count">
            <summary>
            Number of entries currently in the cache.
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.Taxonomy.WriterCache.INameInt32CacheLru.Limit">
            <summary>
            Maximum number of cache entries before eviction.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.WriterCache.IInternalNameInt32CacheLru.MakeRoomLRU">
            <summary>
            If cache is full remove least recently used entries from cache. Return <c>true</c>
            if anything was removed, <c>false</c> otherwise.
            <para/>
            See comment in <see cref="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.AddToCache(Lucene.Net.Facet.Taxonomy.FacetLabel,System.Int32)"/> for an
            explanation why we clean 2/3rds of the cache, and not just one entry.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.WriterCache.IInternalNameInt32CacheLru.Put(Lucene.Net.Facet.Taxonomy.FacetLabel,System.Int32)">
            <summary>
            Add a new value to cache.
            Return true if cache became full and some room need to be made. 
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.Taxonomy.WriterCache.NameCacheLru`1">
            <summary>
            Class for name LRU caches. Users can specify
            a type that can be used as the key of the cache. The
            key may be either a value type or a reference type.
            </summary>
            <typeparam name="TName">The type of key for the cache.</typeparam>
        </member>
        <member name="P:Lucene.Net.Facet.Taxonomy.WriterCache.NameCacheLru`1.Limit">
            <summary>
            Maximum number of cache entries before eviction.
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.Taxonomy.WriterCache.NameCacheLru`1.Count">
            <summary>
            Number of entries currently in the cache.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.WriterCache.NameCacheLru`1.Lucene#Net#Facet#Taxonomy#WriterCache#IInternalNameInt32CacheLru#Put(Lucene.Net.Facet.Taxonomy.FacetLabel,System.Int32)">
            <summary>
            Add a new value to cache.
            Return true if cache became full and some room need to be made. 
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.WriterCache.NameCacheLru`1.Lucene#Net#Facet#Taxonomy#WriterCache#IInternalNameInt32CacheLru#MakeRoomLRU">
            <summary>
            If cache is full remove least recently used entries from cache. Return <c>true</c>
            if anything was removed, <c>false</c> otherwise.
            <para/>
            See comment in <see cref="M:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter.AddToCache(Lucene.Net.Facet.Taxonomy.FacetLabel,System.Int32)"/> for an
            explanation why we clean 2/3rds of the cache, and not just one entry.
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.Taxonomy.WriterCache.ITaxonomyWriterCache">
            <summary>
            <see cref="T:Lucene.Net.Facet.Taxonomy.WriterCache.ITaxonomyWriterCache"/> is a relatively simple interface for a cache of
            category->ordinal mappings, used in ITaxonomyWriter implementations (such as
            <see cref="T:Lucene.Net.Facet.Taxonomy.Directory.DirectoryTaxonomyWriter"/>).
            <para>
            It basically has <see cref="M:Lucene.Net.Facet.Taxonomy.WriterCache.ITaxonomyWriterCache.Put(Lucene.Net.Facet.Taxonomy.FacetLabel,System.Int32)"/> methods for adding a mapping, and <see cref="M:Lucene.Net.Facet.Taxonomy.WriterCache.ITaxonomyWriterCache.Get(Lucene.Net.Facet.Taxonomy.FacetLabel)"/> for looking a
            mapping up the cache. The cache does <b>not</b> guarantee to hold everything
            that has been put into it, and might in fact selectively delete some of the
            mappings (e.g., the ones least recently used). This means that if <see cref="M:Lucene.Net.Facet.Taxonomy.WriterCache.ITaxonomyWriterCache.Get(Lucene.Net.Facet.Taxonomy.FacetLabel)"/>
            returns a negative response, it does not necessarily mean that the category
            doesn't exist - just that it is not in the cache. The caller can only infer
            that the category doesn't exist if it knows the cache to be complete (because
            all the categories were loaded into the cache, and since then no <see cref="M:Lucene.Net.Facet.Taxonomy.WriterCache.ITaxonomyWriterCache.Put(Lucene.Net.Facet.Taxonomy.FacetLabel,System.Int32)"/>
            returned true).
            </para>
            <para>
            However, if it does so, it should clear out large parts of the cache at once,
            because the user will typically need to work hard to recover from every cache
            cleanup (see <see cref="M:Lucene.Net.Facet.Taxonomy.WriterCache.ITaxonomyWriterCache.Put(Lucene.Net.Facet.Taxonomy.FacetLabel,System.Int32)"/>'s return value).
            </para>
            <para>
            <b>NOTE:</b> the cache may be accessed concurrently by multiple threads,
            therefore cache implementations should take this into consideration.
            
            @lucene.experimental
            </para>
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.WriterCache.ITaxonomyWriterCache.Get(Lucene.Net.Facet.Taxonomy.FacetLabel)">
            <summary>
            Lookup a category in the cache, returning its ordinal, or a negative
            number if the category is not in the cache.
            <para>
            It is up to the caller to remember what a negative response means:
            If the caller knows the cache is <i>complete</i> (it was initially
            fed with all the categories, and since then <see cref="M:Lucene.Net.Facet.Taxonomy.WriterCache.ITaxonomyWriterCache.Put(Lucene.Net.Facet.Taxonomy.FacetLabel,System.Int32)"/> never returned true)
            it means the category does not exist. Otherwise, the category might
            still exist, but just be missing from the cache.
            </para>
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.WriterCache.ITaxonomyWriterCache.Put(Lucene.Net.Facet.Taxonomy.FacetLabel,System.Int32)">
            <summary>
            Add a category to the cache, with the given ordinal as the value.
            <para>
            If the implementation keeps only a partial cache (e.g., an LRU cache)
            and finds that its cache is full, it should clear up part of the cache
            and return <c>true</c>. Otherwise, it should return
            <c>false</c>.
            </para>
            <para>
            The reason why the caller needs to know if part of the cache was
            cleared is that in that case it will have to commit its on-disk index
            (so that all the latest category additions can be searched on disk, if
            we can't rely on the cache to contain them).
            </para>
            <para>
            Ordinals should be non-negative. Currently there is no defined way to
            specify that a cache should remember a category does NOT exist.
            It doesn't really matter, because normally the next thing we do after
            finding that a category does not exist is to add it.
            </para>
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.Taxonomy.WriterCache.ITaxonomyWriterCache.IsFull">
            <summary>
            Returns true if the cache is full, such that the next <see cref="M:Lucene.Net.Facet.Taxonomy.WriterCache.ITaxonomyWriterCache.Put(Lucene.Net.Facet.Taxonomy.FacetLabel,System.Int32)"/> will
            evict entries from it, false otherwise.
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.Taxonomy.WriterCache.ITaxonomyWriterCache.Clear">
            <summary>
            Clears the content of the cache. Unlike <see cref="M:System.IDisposable.Dispose"/>, the caller can
            assume that the cache is still operable after this method returns.
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.TopOrdAndSingleQueue">
            <summary>
            Keeps highest results, first by largest <see cref="T:System.Single"/> value,
            then tie break by smallest ord.
            <para/>
            NOTE: This was TopOrdAndFloatQueue in Lucene
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.TopOrdAndSingleQueue.#ctor(System.Int32)">
            <summary>
            Initializes a new instance of <see cref="T:Lucene.Net.Facet.TopOrdAndSingleQueue"/> with the
            specified <paramref name="topN"/> size.
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.TopOrdAndSingleComparer">
            <summary>
            Keeps highest results, first by largest <see cref="T:System.Single"/> value,
            then tie break by smallest ord.
            <para/>
            NOTE: This is a refactoring of TopOrdAndFloatQueue in Lucene
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.TopOrdAndSingleComparer.Default">
            <summary>
            Returns a default sort order comparer for <see cref="T:Lucene.Net.Facet.OrdAndValue`1"/>.
            Keeps highest results, first by largest <see cref="T:System.Single"/> value,
            then tie break by smallest ord.
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.OrdAndValue`1">
            <summary>
            Holds a single entry.
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.OrdAndValue`1.Ord">
            <summary>
            Ordinal of the entry. </summary>
        </member>
        <member name="P:Lucene.Net.Facet.OrdAndValue`1.Value">
            <summary>
            Value associated with the ordinal. </summary>
        </member>
        <member name="M:Lucene.Net.Facet.OrdAndValue`1.#ctor(System.Int32,`0)">
            <summary>
            Default constructor.
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.TopOrdAndInt32Queue">
            <summary>
            Keeps highest results, first by largest <see cref="T:System.Int32"/> value,
            then tie break by smallest ord.
            <para/>
            NOTE: This was TopOrdAndIntQueue in Lucene
            </summary>
        </member>
        <member name="M:Lucene.Net.Facet.TopOrdAndInt32Queue.#ctor(System.Int32)">
            <summary>
            Initializes a new instance of <see cref="T:Lucene.Net.Facet.TopOrdAndInt32Queue"/> with the specified
            <paramref name="topN"/> size.
            </summary>
        </member>
        <member name="T:Lucene.Net.Facet.TopOrdAndInt32Comparer">
            <summary>
            Keeps highest results, first by largest <see cref="T:System.Int32"/> value,
            then tie break by smallest ord.
            <para/>
            NOTE: This is a refactoring of TopOrdAndIntQueue in Lucene
            </summary>
        </member>
        <member name="P:Lucene.Net.Facet.TopOrdAndInt32Comparer.Default">
            <summary>
            Returns a default sort order comparer for <see cref="T:Lucene.Net.Facet.OrdAndValue`1"/>.
            Keeps highest results, first by largest <see cref="T:System.Int32"/> value,
            then tie break by smallest ord.
            </summary>
        </member>
        <member name="T:Lucene.Net.Documents.Extensions.DocumentExtensions">
            <summary>
            LUCENENET specific extensions to the <see cref="T:Lucene.Net.Documents.Document"/> class.
            </summary>
        </member>
        <member name="M:Lucene.Net.Documents.Extensions.DocumentExtensions.AddSortedSetDocValuesFacetField(Lucene.Net.Documents.Document,System.String,System.String)">
            <summary>
            Adds a new <see cref="T:Lucene.Net.Facet.SortedSet.SortedSetDocValuesFacetField"/>.
            </summary>
            <remarks>
            Add a <see cref="T:Lucene.Net.Facet.SortedSet.SortedSetDocValuesFacetField"/> to your <see cref="T:Lucene.Net.Documents.Document"/> for every facet
            label to be indexed via <see cref="T:Lucene.Net.Index.SortedSetDocValues"/>. 
            </remarks>
            <param name="document">This <see cref="T:Lucene.Net.Documents.Document"/>.</param>
            <param name="dim">Dimension for this field.</param>
            <param name="label">Label for this field.</param>
            <returns>The field that was added to this <see cref="T:Lucene.Net.Documents.Document"/>.</returns>
            <exception cref="T:System.ArgumentNullException">This <paramref name="document"/> is <c>null</c>. </exception>
        </member>
        <member name="M:Lucene.Net.Documents.Extensions.DocumentExtensions.AddAssociationFacetField(Lucene.Net.Documents.Document,Lucene.Net.Util.BytesRef,System.String,System.String[])">
            <summary>
            Adds a new <see cref="T:Lucene.Net.Facet.Taxonomy.AssociationFacetField"/> using <paramref name="dim"/> and <paramref name="path"/> and an
            association.
            </summary>
            <param name="document">This <see cref="T:Lucene.Net.Documents.Document"/>.</param>
            <param name="assoc">Associated value.</param>
            <param name="dim">Dimension for this field.</param>
            <param name="path">Facet path for this field.</param>
            <returns>The field that was added to this <see cref="T:Lucene.Net.Documents.Document"/>.</returns>
            <exception cref="T:System.ArgumentNullException">This <paramref name="document"/> is <c>null</c>. </exception>
        </member>
        <member name="M:Lucene.Net.Documents.Extensions.DocumentExtensions.AddInt32AssociationFacetField(Lucene.Net.Documents.Document,System.Int32,System.String,System.String[])">
            <summary>
            Adds a new <see cref="T:Lucene.Net.Facet.Taxonomy.Int32AssociationFacetField"/> using <paramref name="dim"/> and <paramref name="path"/> and an
            <see cref="T:System.Int32"/> association.
            </summary>
            <param name="document">This <see cref="T:Lucene.Net.Documents.Document"/>.</param>
            <param name="assoc">Associated value.</param>
            <param name="dim">Dimension for this field.</param>
            <param name="path">Facet path for this field.</param>
            <returns>The field that was added to this <see cref="T:Lucene.Net.Documents.Document"/>.</returns>
            <exception cref="T:System.ArgumentNullException">This <paramref name="document"/> is <c>null</c>. </exception>
        </member>
        <member name="M:Lucene.Net.Documents.Extensions.DocumentExtensions.AddSingleAssociationFacetField(Lucene.Net.Documents.Document,System.Single,System.String,System.String[])">
            <summary>
            Adds a new <see cref="T:Lucene.Net.Facet.Taxonomy.SingleAssociationFacetField"/> using <paramref name="dim"/> and <paramref name="path"/> and a
            <see cref="T:System.Single"/> association.
            </summary>
            <param name="document">This <see cref="T:Lucene.Net.Documents.Document"/>.</param>
            <param name="assoc">Associated value.</param>
            <param name="dim">Dimension for this field.</param>
            <param name="path">Facet path for this field.</param>
            <returns>The field that was added to this <see cref="T:Lucene.Net.Documents.Document"/>.</returns>
            <exception cref="T:System.ArgumentNullException">This <paramref name="document"/> is <c>null</c>. </exception>
        </member>
        <member name="M:Lucene.Net.Documents.Extensions.DocumentExtensions.AddFacetField(Lucene.Net.Documents.Document,System.String,System.String[])">
            <summary>
            Adds a new <see cref="T:Lucene.Net.Facet.FacetField"/> with the specified <paramref name="dim"/> and
            <paramref name="path"/>. 
            </summary>
            <param name="document">This <see cref="T:Lucene.Net.Documents.Document"/>.</param>
            <param name="dim">Dimension for this field.</param>
            <param name="path">Facet path for this field.</param>
            <returns>The field that was added to this <see cref="T:Lucene.Net.Documents.Document"/>.</returns>
            <exception cref="T:System.ArgumentNullException">This <paramref name="document"/> is <c>null</c>. </exception>
        </member>
    </members>
</doc>
