{
  "Lucene.Net.Documents.html": {
    "href": "Lucene.Net.Documents.html",
    "title": "Namespace Lucene.Net.Documents | Apache Lucene.NET 4.8.0-beta00013 Documentation",
    "keywords": "Namespace Lucene.Net.Documents <!-- Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. --> Misc extensions of the Document/Field API. Classes LazyDocument Defers actually loading a field's value until you ask for it. You must not use the returned Field instances after the provided reader has been closed. LazyDocument.LazyField This is a Lucene.NET INTERNAL API, use at your own risk"
  },
  "Lucene.Net.Documents.LazyDocument.html": {
    "href": "Lucene.Net.Documents.LazyDocument.html",
    "title": "Class LazyDocument | Apache Lucene.NET 4.8.0-beta00013 Documentation",
    "keywords": "Class LazyDocument Defers actually loading a field's value until you ask for it. You must not use the returned Field instances after the provided reader has been closed. Inheritance System.Object LazyDocument Inherited Members System.Object.Equals(System.Object) System.Object.Equals(System.Object, System.Object) System.Object.GetHashCode() System.Object.GetType() System.Object.MemberwiseClone() System.Object.ReferenceEquals(System.Object, System.Object) System.Object.ToString() Namespace : Lucene.Net.Documents Assembly : Lucene.Net.Misc.dll Syntax public class LazyDocument Constructors | Improve this Doc View Source LazyDocument(IndexReader, Int32) Declaration public LazyDocument(IndexReader reader, int docID) Parameters Type Name Description Lucene.Net.Index.IndexReader reader System.Int32 docID Methods | Improve this Doc View Source GetField(FieldInfo) Creates an IndexableField whose value will be lazy loaded if and when it is used. NOTE: This method must be called once for each value of the field name specified in sequence that the values exist. This method may not be used to generate multiple, lazy, IndexableField instances refering to the same underlying IndexableField instance. The lazy loading of field values from all instances of IndexableField objects returned by this method are all backed by a single Document per LazyDocument instance. Declaration public virtual IIndexableField GetField(FieldInfo fieldInfo) Parameters Type Name Description Lucene.Net.Index.FieldInfo fieldInfo Returns Type Description Lucene.Net.Index.IIndexableField See Also GetField(FieldInfo)"
  },
  "Lucene.Net.Documents.LazyDocument.LazyField.html": {
    "href": "Lucene.Net.Documents.LazyDocument.LazyField.html",
    "title": "Class LazyDocument.LazyField | Apache Lucene.NET 4.8.0-beta00013 Documentation",
    "keywords": "Class LazyDocument.LazyField This is a Lucene.NET INTERNAL API, use at your own risk Inheritance System.Object LazyDocument.LazyField Implements Lucene.Net.Index.IIndexableField Inherited Members System.Object.Equals(System.Object) System.Object.Equals(System.Object, System.Object) System.Object.GetHashCode() System.Object.GetType() System.Object.MemberwiseClone() System.Object.ReferenceEquals(System.Object, System.Object) System.Object.ToString() Namespace : Lucene.Net.Documents Assembly : Lucene.Net.Misc.dll Syntax public class LazyField : IIndexableField Properties | Improve this Doc View Source Boost Gets the boost factor on this field. Declaration public virtual float Boost { get; } Property Value Type Description System.Single | Improve this Doc View Source FieldType Returns the Lucene.Net.Documents.FieldType for this field as type Lucene.Net.Documents.FieldType . Declaration public virtual FieldType FieldType { get; } Property Value Type Description Lucene.Net.Documents.FieldType | Improve this Doc View Source HasBeenLoaded non-private for test only access This is a Lucene.NET INTERNAL API, use at your own risk Declaration public virtual bool HasBeenLoaded { get; } Property Value Type Description System.Boolean | Improve this Doc View Source IndexableFieldType Returns the Lucene.Net.Documents.FieldType for this field as type Lucene.Net.Index.IIndexableFieldType . Declaration public virtual IIndexableFieldType IndexableFieldType { get; } Property Value Type Description Lucene.Net.Index.IIndexableFieldType | Improve this Doc View Source Name The field's name Declaration public virtual string Name { get; } Property Value Type Description System.String | Improve this Doc View Source NumericType Gets the Lucene.Net.Documents.NumericFieldType of the underlying value, or NONE if the value is not set or non-numeric. Expert: The difference between this property and NumericType is this is represents the current state of the field (whether being written or read) and the FieldType property represents instructions on how the field will be written, but does not re-populate when reading back from an index (it is write-only). In Java, the numeric type was determined by checking the type of GetNumericValue() . However, since there are no reference number types in .NET, using GetNumericValue() so will cause boxing/unboxing. It is therefore recommended to use this property to check the underlying type and the corresponding Get*Value() method to retrieve the value. NOTE: Since Lucene codecs do not support BYTE or INT16 , fields created with these types will always be INT32 when read back from the index. Declaration public virtual NumericFieldType NumericType { get; } Property Value Type Description Lucene.Net.Documents.NumericFieldType Methods | Improve this Doc View Source GetBinaryValue() Non-null if this field has a binary value. Declaration public virtual BytesRef GetBinaryValue() Returns Type Description Lucene.Net.Util.BytesRef | Improve this Doc View Source GetByteValue() Returns the field value as System.Byte or null if the type is non-numeric. Declaration public virtual byte? GetByteValue() Returns Type Description System.Nullable < System.Byte > The field value or null if the type is non-numeric. | Improve this Doc View Source GetDoubleValue() Returns the field value as System.Double or null if the type is non-numeric. Declaration public virtual double? GetDoubleValue() Returns Type Description System.Nullable < System.Double > The field value or null if the type is non-numeric. | Improve this Doc View Source GetInt16Value() Returns the field value as System.Int16 or null if the type is non-numeric. Declaration public virtual short? GetInt16Value() Returns Type Description System.Nullable < System.Int16 > The field value or null if the type is non-numeric. | Improve this Doc View Source GetInt32Value() Returns the field value as System.Int32 or null if the type is non-numeric. Declaration public virtual int? GetInt32Value() Returns Type Description System.Nullable < System.Int32 > The field value or null if the type is non-numeric. | Improve this Doc View Source GetInt64Value() Returns the field value as System.Int64 or null if the type is non-numeric. Declaration public virtual long? GetInt64Value() Returns Type Description System.Nullable < System.Int64 > The field value or null if the type is non-numeric. | Improve this Doc View Source GetNumericValue() Declaration [Obsolete(\"In .NET, use of this method will cause boxing/unboxing. Instead, use the NumericType property to check the underlying type and call the appropriate GetXXXValue() method to retrieve the value.\")] public virtual object GetNumericValue() Returns Type Description System.Object | Improve this Doc View Source GetReaderValue() The value of the field as a System.IO.TextReader , or null . If null , the System.String value or binary value is used. Exactly one of GetStringValue() , GetReaderValue() , and GetBinaryValue() must be set. Declaration public virtual TextReader GetReaderValue() Returns Type Description System.IO.TextReader | Improve this Doc View Source GetSingleValue() Returns the field value as System.Single or null if the type is non-numeric. Declaration public virtual float? GetSingleValue() Returns Type Description System.Nullable < System.Single > The field value or null if the type is non-numeric. | Improve this Doc View Source GetStringValue() The value of the field as a System.String , or null . If null , the System.IO.TextReader value or binary value is used. Exactly one of GetStringValue() , GetReaderValue() , and GetBinaryValue() must be set. Declaration public virtual string GetStringValue() Returns Type Description System.String The string representation of the value if it is either a System.String or numeric type. | Improve this Doc View Source GetStringValue(IFormatProvider) The value of the field as a System.String , or null . If null , the System.IO.TextReader value or binary value is used. Exactly one of GetStringValue() , GetReaderValue() , and GetBinaryValue() must be set. Declaration public virtual string GetStringValue(IFormatProvider provider) Parameters Type Name Description System.IFormatProvider provider An object that supplies culture-specific formatting information. This parameter has no effect if this field is non-numeric. Returns Type Description System.String The string representation of the value if it is either a System.String or numeric type. | Improve this Doc View Source GetStringValue(String) The value of the field as a System.String , or null . If null , the System.IO.TextReader value or binary value is used. Exactly one of GetStringValue() , GetReaderValue() , and GetBinaryValue() must be set. Declaration public virtual string GetStringValue(string format) Parameters Type Name Description System.String format A standard or custom numeric format string. This parameter has no effect if this field is non-numeric. Returns Type Description System.String The string representation of the value if it is either a System.String or numeric type. | Improve this Doc View Source GetStringValue(String, IFormatProvider) The value of the field as a System.String , or null . If null , the System.IO.TextReader value or binary value is used. Exactly one of GetStringValue() , GetReaderValue() , and GetBinaryValue() must be set. Declaration public virtual string GetStringValue(string format, IFormatProvider provider) Parameters Type Name Description System.String format A standard or custom numeric format string. This parameter has no effect if this field is non-numeric. System.IFormatProvider provider An object that supplies culture-specific formatting information. This parameter has no effect if this field is non-numeric. Returns Type Description System.String The string representation of the value if it is either a System.String or numeric type. | Improve this Doc View Source GetTokenStream(Analyzer) Declaration public virtual TokenStream GetTokenStream(Analyzer analyzer) Parameters Type Name Description Lucene.Net.Analysis.Analyzer analyzer Returns Type Description Lucene.Net.Analysis.TokenStream Implements Lucene.Net.Index.IIndexableField"
  },
  "Lucene.Net.Index.CompoundFileExtractor.html": {
    "href": "Lucene.Net.Index.CompoundFileExtractor.html",
    "title": "Class CompoundFileExtractor | Apache Lucene.NET 4.8.0-beta00013 Documentation",
    "keywords": "Class CompoundFileExtractor Command-line tool for extracting sub-files out of a compound file. Inheritance System.Object CompoundFileExtractor Inherited Members System.Object.Equals(System.Object) System.Object.Equals(System.Object, System.Object) System.Object.GetHashCode() System.Object.GetType() System.Object.MemberwiseClone() System.Object.ReferenceEquals(System.Object, System.Object) System.Object.ToString() Namespace : Lucene.Net.Index Assembly : Lucene.Net.Misc.dll Syntax public static class CompoundFileExtractor Methods | Improve this Doc View Source Main(String[]) Prints the filename and size of each file within a given compound file. Add the -extract flag to extract files to the current working directory. In order to make the extracted version of the index work, you have to copy the segments file from the compound index into the directory where the extracted files are stored. Declaration public static void Main(string[] args) Parameters Type Name Description System.String [] args"
  },
  "Lucene.Net.Index.html": {
    "href": "Lucene.Net.Index.html",
    "title": "Namespace Lucene.Net.Index | Apache Lucene.NET 4.8.0-beta00013 Documentation",
    "keywords": "Namespace Lucene.Net.Index <!-- Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. --> Misc index tools and index support. Classes CompoundFileExtractor Command-line tool for extracting sub-files out of a compound file. IndexSplitter Command-line tool that enables listing segments in an index, copying specific segments to another index, and deleting segments from an index. This tool does file-level copying of segments files. This means it's unable to split apart a single segment into multiple segments. For example if your index is a single segment, this tool won't help. Also, it does basic file-level copying (using simple Stream) so it will not work with non FSDirectory Directory impls. This is a Lucene.NET EXPERIMENTAL API, use at your own risk You can easily accidentally remove segments from your index so be careful! MultiPassIndexSplitter This tool splits input index into multiple equal parts. The method employed here uses AddIndexes(IndexReader[]) where the input data comes from the input index with artificially applied deletes to the document id-s that fall outside the selected partition. Note 1: Deletes are only applied to a buffered list of deleted docs and don't affect the source index - this tool works also with read-only indexes. Note 2: the disadvantage of this tool is that source index needs to be read as many times as there are parts to be created, hence the name of this tool. NOTE : this tool is unaware of documents added atomically via AddDocuments(IEnumerable<IEnumerable<IIndexableField>>, Analyzer) or UpdateDocuments(Term, IEnumerable<IEnumerable<IIndexableField>>, Analyzer) , which means it can easily break up such document groups. PKIndexSplitter Split an index based on a Lucene.Net.Search.Filter ."
  },
  "Lucene.Net.Index.IndexSplitter.html": {
    "href": "Lucene.Net.Index.IndexSplitter.html",
    "title": "Class IndexSplitter | Apache Lucene.NET 4.8.0-beta00013 Documentation",
    "keywords": "Class IndexSplitter Command-line tool that enables listing segments in an index, copying specific segments to another index, and deleting segments from an index. This tool does file-level copying of segments files. This means it's unable to split apart a single segment into multiple segments. For example if your index is a single segment, this tool won't help. Also, it does basic file-level copying (using simple Stream) so it will not work with non FSDirectory Directory impls. This is a Lucene.NET EXPERIMENTAL API, use at your own risk You can easily accidentally remove segments from your index so be careful! Inheritance System.Object IndexSplitter Inherited Members System.Object.Equals(System.Object) System.Object.Equals(System.Object, System.Object) System.Object.GetHashCode() System.Object.GetType() System.Object.MemberwiseClone() System.Object.ReferenceEquals(System.Object, System.Object) System.Object.ToString() Namespace : Lucene.Net.Index Assembly : Lucene.Net.Misc.dll Syntax public class IndexSplitter Constructors | Improve this Doc View Source IndexSplitter(DirectoryInfo) Declaration public IndexSplitter(DirectoryInfo dir) Parameters Type Name Description System.IO.DirectoryInfo dir Properties | Improve this Doc View Source Infos Declaration public SegmentInfos Infos { get; set; } Property Value Type Description Lucene.Net.Index.SegmentInfos Methods | Improve this Doc View Source ListSegments() Declaration public virtual void ListSegments() | Improve this Doc View Source Main(String[]) Declaration public static void Main(string[] args) Parameters Type Name Description System.String [] args | Improve this Doc View Source Remove(ICollection<String>) Declaration public virtual void Remove(ICollection<string> segs) Parameters Type Name Description System.Collections.Generic.ICollection < System.String > segs | Improve this Doc View Source Split(DirectoryInfo, ICollection<String>) Declaration public virtual void Split(DirectoryInfo destDir, ICollection<string> segs) Parameters Type Name Description System.IO.DirectoryInfo destDir System.Collections.Generic.ICollection < System.String > segs"
  },
  "Lucene.Net.Index.MultiPassIndexSplitter.html": {
    "href": "Lucene.Net.Index.MultiPassIndexSplitter.html",
    "title": "Class MultiPassIndexSplitter | Apache Lucene.NET 4.8.0-beta00013 Documentation",
    "keywords": "Class MultiPassIndexSplitter This tool splits input index into multiple equal parts. The method employed here uses AddIndexes(IndexReader[]) where the input data comes from the input index with artificially applied deletes to the document id-s that fall outside the selected partition. Note 1: Deletes are only applied to a buffered list of deleted docs and don't affect the source index - this tool works also with read-only indexes. Note 2: the disadvantage of this tool is that source index needs to be read as many times as there are parts to be created, hence the name of this tool. NOTE : this tool is unaware of documents added atomically via AddDocuments(IEnumerable<IEnumerable<IIndexableField>>, Analyzer) or UpdateDocuments(Term, IEnumerable<IEnumerable<IIndexableField>>, Analyzer) , which means it can easily break up such document groups. Inheritance System.Object MultiPassIndexSplitter Inherited Members System.Object.Equals(System.Object) System.Object.Equals(System.Object, System.Object) System.Object.GetHashCode() System.Object.GetType() System.Object.MemberwiseClone() System.Object.ReferenceEquals(System.Object, System.Object) System.Object.ToString() Namespace : Lucene.Net.Index Assembly : Lucene.Net.Misc.dll Syntax public class MultiPassIndexSplitter Methods | Improve this Doc View Source Main(String[]) Declaration public static void Main(string[] args) Parameters Type Name Description System.String [] args | Improve this Doc View Source Split(LuceneVersion, IndexReader, Directory[], Boolean) Split source index into multiple parts. Declaration public virtual void Split(LuceneVersion version, IndexReader in, Directory[] outputs, bool seq) Parameters Type Name Description Lucene.Net.Util.LuceneVersion version lucene compatibility version Lucene.Net.Index.IndexReader in source index, can have deletions, can have multiple segments (or multiple readers). Lucene.Net.Store.Directory [] outputs list of directories where the output parts will be stored. System.Boolean seq if true, then the source index will be split into equal increasing ranges of document id-s. If false, source document id-s will be assigned in a deterministic round-robin fashion to one of the output splits. Exceptions Type Condition System.IO.IOException If there is a low-level I/O error"
  },
  "Lucene.Net.Index.PKIndexSplitter.html": {
    "href": "Lucene.Net.Index.PKIndexSplitter.html",
    "title": "Class PKIndexSplitter | Apache Lucene.NET 4.8.0-beta00013 Documentation",
    "keywords": "Class PKIndexSplitter Split an index based on a Lucene.Net.Search.Filter . Inheritance System.Object PKIndexSplitter Inherited Members System.Object.Equals(System.Object) System.Object.Equals(System.Object, System.Object) System.Object.GetHashCode() System.Object.GetType() System.Object.MemberwiseClone() System.Object.ReferenceEquals(System.Object, System.Object) System.Object.ToString() Namespace : Lucene.Net.Index Assembly : Lucene.Net.Misc.dll Syntax public class PKIndexSplitter Constructors | Improve this Doc View Source PKIndexSplitter(Directory, Directory, Directory, Term, IndexWriterConfig, IndexWriterConfig) Declaration public PKIndexSplitter(Directory input, Directory dir1, Directory dir2, Term midTerm, IndexWriterConfig config1, IndexWriterConfig config2) Parameters Type Name Description Lucene.Net.Store.Directory input Lucene.Net.Store.Directory dir1 Lucene.Net.Store.Directory dir2 Lucene.Net.Index.Term midTerm Lucene.Net.Index.IndexWriterConfig config1 Lucene.Net.Index.IndexWriterConfig config2 | Improve this Doc View Source PKIndexSplitter(Directory, Directory, Directory, Filter, IndexWriterConfig, IndexWriterConfig) Declaration public PKIndexSplitter(Directory input, Directory dir1, Directory dir2, Filter docsInFirstIndex, IndexWriterConfig config1, IndexWriterConfig config2) Parameters Type Name Description Lucene.Net.Store.Directory input Lucene.Net.Store.Directory dir1 Lucene.Net.Store.Directory dir2 Lucene.Net.Search.Filter docsInFirstIndex Lucene.Net.Index.IndexWriterConfig config1 Lucene.Net.Index.IndexWriterConfig config2 | Improve this Doc View Source PKIndexSplitter(LuceneVersion, Directory, Directory, Directory, Term) Split an index based on a given primary key term and a 'middle' term. If the middle term is present, it's sent to dir2. Declaration public PKIndexSplitter(LuceneVersion version, Directory input, Directory dir1, Directory dir2, Term midTerm) Parameters Type Name Description Lucene.Net.Util.LuceneVersion version Lucene.Net.Store.Directory input Lucene.Net.Store.Directory dir1 Lucene.Net.Store.Directory dir2 Lucene.Net.Index.Term midTerm | Improve this Doc View Source PKIndexSplitter(LuceneVersion, Directory, Directory, Directory, Filter) Split an index based on a Lucene.Net.Search.Filter . All documents that match the filter are sent to dir1, remaining ones to dir2. Declaration public PKIndexSplitter(LuceneVersion version, Directory input, Directory dir1, Directory dir2, Filter docsInFirstIndex) Parameters Type Name Description Lucene.Net.Util.LuceneVersion version Lucene.Net.Store.Directory input Lucene.Net.Store.Directory dir1 Lucene.Net.Store.Directory dir2 Lucene.Net.Search.Filter docsInFirstIndex Methods | Improve this Doc View Source Split() Declaration public virtual void Split()"
  },
  "Lucene.Net.Index.Sorter.BlockJoinComparerSource.html": {
    "href": "Lucene.Net.Index.Sorter.BlockJoinComparerSource.html",
    "title": "Class BlockJoinComparerSource | Apache Lucene.NET 4.8.0-beta00013 Documentation",
    "keywords": "Class BlockJoinComparerSource Helper class to sort readers that contain blocks of documents. Note that this class is intended to used with SortingMergePolicy , and for other purposes has some limitations: Cannot yet be used with SearchAfter(ScoreDoc, Query, Filter, Int32, Sort) Filling sort field values is not yet supported. This is a Lucene.NET EXPERIMENTAL API, use at your own risk Inheritance System.Object Lucene.Net.Search.FieldComparerSource BlockJoinComparerSource Inherited Members System.Object.Equals(System.Object) System.Object.Equals(System.Object, System.Object) System.Object.GetHashCode() System.Object.GetType() System.Object.MemberwiseClone() System.Object.ReferenceEquals(System.Object, System.Object) Namespace : Lucene.Net.Index.Sorter Assembly : Lucene.Net.Misc.dll Syntax public class BlockJoinComparerSource : FieldComparerSource Constructors | Improve this Doc View Source BlockJoinComparerSource(Filter, Sort) Create a new BlockJoinComparerSource, sorting only blocks of documents with parentSort and not reordering children with a block. Declaration public BlockJoinComparerSource(Filter parentsFilter, Sort parentSort) Parameters Type Name Description Lucene.Net.Search.Filter parentsFilter Filter identifying parent documents Lucene.Net.Search.Sort parentSort Sort for parent documents | Improve this Doc View Source BlockJoinComparerSource(Filter, Sort, Sort) Create a new BlockJoinComparerSource, specifying the sort order for both blocks of documents and children within a block. Declaration public BlockJoinComparerSource(Filter parentsFilter, Sort parentSort, Sort childSort) Parameters Type Name Description Lucene.Net.Search.Filter parentsFilter Filter identifying parent documents Lucene.Net.Search.Sort parentSort Sort for parent documents Lucene.Net.Search.Sort childSort Sort for child documents in the same block Methods | Improve this Doc View Source NewComparer(String, Int32, Int32, Boolean) Declaration public override FieldComparer NewComparer(string fieldname, int numHits, int sortPos, bool reversed) Parameters Type Name Description System.String fieldname System.Int32 numHits System.Int32 sortPos System.Boolean reversed Returns Type Description Lucene.Net.Search.FieldComparer Overrides FieldComparerSource.NewComparer(String, Int32, Int32, Boolean) | Improve this Doc View Source ToString() Declaration public override string ToString() Returns Type Description System.String Overrides System.Object.ToString()"
  },
  "Lucene.Net.Index.Sorter.EarlyTerminatingSortingCollector.html": {
    "href": "Lucene.Net.Index.Sorter.EarlyTerminatingSortingCollector.html",
    "title": "Class EarlyTerminatingSortingCollector | Apache Lucene.NET 4.8.0-beta00013 Documentation",
    "keywords": "Class EarlyTerminatingSortingCollector A Lucene.Net.Search.ICollector that early terminates collection of documents on a per-segment basis, if the segment was sorted according to the given Lucene.Net.Search.Sort . NOTE: the Lucene.Net.Search.ICollector detects sorted segments according to SortingMergePolicy , so it's best used in conjunction with it. Also, it collects up to a specified m_numDocsToCollect from each segment, and therefore is mostly suitable for use in conjunction with collectors such as TopDocsCollector<T> , and not e.g. TotalHitCountCollector . NOTE : If you wrap a TopDocsCollector<T> that sorts in the same order as the index order, the returned GetTopDocs() will be correct. However the total of TotalHits hit count will be underestimated since not all matching documents will have been collected. NOTE : This Lucene.Net.Search.ICollector uses ToString() to detect whether a segment was sorted with the same Lucene.Net.Search.Sort . This has two implications: if a custom comparer is not implemented correctly and returns different identifiers for equivalent instances, this collector will not detect sorted segments, if you suddenly change the Lucene.Net.Index.IndexWriter 's SortingMergePolicy to sort according to another criterion and if both the old and the new Lucene.Net.Search.Sort s have the same identifier, this Lucene.Net.Search.ICollector will incorrectly detect sorted segments. @lucene.experimental Inheritance System.Object EarlyTerminatingSortingCollector Implements Lucene.Net.Search.ICollector Inherited Members System.Object.Equals(System.Object) System.Object.Equals(System.Object, System.Object) System.Object.GetHashCode() System.Object.GetType() System.Object.MemberwiseClone() System.Object.ReferenceEquals(System.Object, System.Object) System.Object.ToString() Namespace : Lucene.Net.Index.Sorter Assembly : Lucene.Net.Misc.dll Syntax public class EarlyTerminatingSortingCollector : ICollector Constructors | Improve this Doc View Source EarlyTerminatingSortingCollector(ICollector, Sort, Int32) Create a new EarlyTerminatingSortingCollector instance. Declaration public EarlyTerminatingSortingCollector(ICollector in, Sort sort, int numDocsToCollect) Parameters Type Name Description Lucene.Net.Search.ICollector in the collector to wrap Lucene.Net.Search.Sort sort the sort you are sorting the search results on System.Int32 numDocsToCollect the number of documents to collect on each segment. When wrapping a TopDocsCollector<T> , this number should be the number of hits. Fields | Improve this Doc View Source m_in The wrapped Collector Declaration protected readonly ICollector m_in Field Value Type Description Lucene.Net.Search.ICollector | Improve this Doc View Source m_numDocsToCollect Number of documents to collect in each segment Declaration protected readonly int m_numDocsToCollect Field Value Type Description System.Int32 | Improve this Doc View Source m_segmentSorted True if the current segment being processed is sorted by Sort() Declaration protected bool m_segmentSorted Field Value Type Description System.Boolean | Improve this Doc View Source m_segmentTotalCollect Number of documents to collect in the current segment being processed Declaration protected int m_segmentTotalCollect Field Value Type Description System.Int32 | Improve this Doc View Source m_sort Sort used to sort the search results Declaration protected readonly Sort m_sort Field Value Type Description Lucene.Net.Search.Sort Properties | Improve this Doc View Source AcceptsDocsOutOfOrder Declaration public virtual bool AcceptsDocsOutOfOrder { get; } Property Value Type Description System.Boolean Methods | Improve this Doc View Source Collect(Int32) Declaration public virtual void Collect(int doc) Parameters Type Name Description System.Int32 doc | Improve this Doc View Source SetNextReader(AtomicReaderContext) Declaration public virtual void SetNextReader(AtomicReaderContext context) Parameters Type Name Description Lucene.Net.Index.AtomicReaderContext context | Improve this Doc View Source SetScorer(Scorer) Declaration public virtual void SetScorer(Scorer scorer) Parameters Type Name Description Lucene.Net.Search.Scorer scorer Implements Lucene.Net.Search.ICollector"
  },
  "Lucene.Net.Index.Sorter.html": {
    "href": "Lucene.Net.Index.Sorter.html",
    "title": "Namespace Lucene.Net.Index.Sorter | Apache Lucene.NET 4.8.0-beta00013 Documentation",
    "keywords": "Namespace Lucene.Net.Index.Sorter <!-- Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. --> Provides index sorting capablities. The application can use any Sort specification, e.g. to sort by fields using DocValues or FieldCache, or to reverse the order of the documents (by using SortField.Type.DOC in reverse). Multi-level sorts can be specified the same way you would when searching, by building Sort from multiple SortFields. SortingMergePolicy can be used to make Lucene sort segments before merging them. This will ensure that every segment resulting from a merge will be sorted according to the provided <xref:Lucene.Net.Search.Sort>. This however makes merging and thus indexing slower. Sorted segments allow for early query termination when the sort order matches index order. This makes query execution faster since not all documents need to be visited. Please note that this is an expert feature and should not be used without a deep understanding of Lucene merging and document collection. Classes BlockJoinComparerSource Helper class to sort readers that contain blocks of documents. Note that this class is intended to used with SortingMergePolicy , and for other purposes has some limitations: Cannot yet be used with SearchAfter(ScoreDoc, Query, Filter, Int32, Sort) Filling sort field values is not yet supported. This is a Lucene.NET EXPERIMENTAL API, use at your own risk EarlyTerminatingSortingCollector A Lucene.Net.Search.ICollector that early terminates collection of documents on a per-segment basis, if the segment was sorted according to the given Lucene.Net.Search.Sort . NOTE: the Lucene.Net.Search.ICollector detects sorted segments according to SortingMergePolicy , so it's best used in conjunction with it. Also, it collects up to a specified m_numDocsToCollect from each segment, and therefore is mostly suitable for use in conjunction with collectors such as TopDocsCollector<T> , and not e.g. TotalHitCountCollector . NOTE : If you wrap a TopDocsCollector<T> that sorts in the same order as the index order, the returned GetTopDocs() will be correct. However the total of TotalHits hit count will be underestimated since not all matching documents will have been collected. NOTE : This Lucene.Net.Search.ICollector uses ToString() to detect whether a segment was sorted with the same Lucene.Net.Search.Sort . This has two implications: if a custom comparer is not implemented correctly and returns different identifiers for equivalent instances, this collector will not detect sorted segments, if you suddenly change the Lucene.Net.Index.IndexWriter 's SortingMergePolicy to sort according to another criterion and if both the old and the new Lucene.Net.Search.Sort s have the same identifier, this Lucene.Net.Search.ICollector will incorrectly detect sorted segments. @lucene.experimental SortingAtomicReader An Lucene.Net.Index.AtomicReader which supports sorting documents by a given Lucene.Net.Search.Sort . You can use this class to sort an index as follows: IndexWriter writer; // writer to which the sorted index will be added DirectoryReader reader; // reader on the input index Sort sort; // determines how the documents are sorted AtomicReader sortingReader = SortingAtomicReader.Wrap(SlowCompositeReaderWrapper.Wrap(reader), sort); writer.AddIndexes(reader); reader.Dispose(); // alternatively, you can use a using block writer.Dispose(); // alternatively, you can use a using block This is a Lucene.NET EXPERIMENTAL API, use at your own risk SortingMergePolicy A Lucene.Net.Index.MergePolicy that reorders documents according to a Lucene.Net.Search.Sort before merging them. As a consequence, all segments resulting from a merge will be sorted while segments resulting from a flush will be in the order in which documents have been added. NOTE : Never use this policy if you rely on AddDocuments(IEnumerable<IEnumerable<IIndexableField>>, Analyzer) to have sequentially-assigned doc IDs, this policy will scatter doc IDs. NOTE : This policy should only be used with idempotent Lucene.Net.Search.Sort s so that the order of segments is predictable. For example, using INDEXORDER in reverse (which is not idempotent) will make the order of documents in a segment depend on the number of times the segment has been merged. This is a Lucene.NET EXPERIMENTAL API, use at your own risk"
  },
  "Lucene.Net.Index.Sorter.SortingAtomicReader.html": {
    "href": "Lucene.Net.Index.Sorter.SortingAtomicReader.html",
    "title": "Class SortingAtomicReader | Apache Lucene.NET 4.8.0-beta00013 Documentation",
    "keywords": "Class SortingAtomicReader An Lucene.Net.Index.AtomicReader which supports sorting documents by a given Lucene.Net.Search.Sort . You can use this class to sort an index as follows: IndexWriter writer; // writer to which the sorted index will be added DirectoryReader reader; // reader on the input index Sort sort; // determines how the documents are sorted AtomicReader sortingReader = SortingAtomicReader.Wrap(SlowCompositeReaderWrapper.Wrap(reader), sort); writer.AddIndexes(reader); reader.Dispose(); // alternatively, you can use a using block writer.Dispose(); // alternatively, you can use a using block This is a Lucene.NET EXPERIMENTAL API, use at your own risk Inheritance System.Object Lucene.Net.Index.IndexReader Lucene.Net.Index.AtomicReader Lucene.Net.Index.FilterAtomicReader SortingAtomicReader Implements System.IDisposable Inherited Members Lucene.Net.Index.FilterAtomicReader.Unwrap(Lucene.Net.Index.AtomicReader) Lucene.Net.Index.FilterAtomicReader.m_input Lucene.Net.Index.FilterAtomicReader.FieldInfos Lucene.Net.Index.FilterAtomicReader.NumDocs Lucene.Net.Index.FilterAtomicReader.MaxDoc Lucene.Net.Index.FilterAtomicReader.DoClose() Lucene.Net.Index.FilterAtomicReader.ToString() Lucene.Net.Index.FilterAtomicReader.CheckIntegrity() Lucene.Net.Index.AtomicReader.Context Lucene.Net.Index.AtomicReader.AtomicContext AtomicReader.HasNorms(String) Lucene.Net.Index.AtomicReader.DocFreq(Lucene.Net.Index.Term) Lucene.Net.Index.AtomicReader.TotalTermFreq(Lucene.Net.Index.Term) AtomicReader.GetSumDocFreq(String) AtomicReader.GetDocCount(String) AtomicReader.GetSumTotalTermFreq(String) AtomicReader.GetTerms(String) Lucene.Net.Index.AtomicReader.GetTermDocsEnum(Lucene.Net.Index.Term) Lucene.Net.Index.AtomicReader.GetTermPositionsEnum(Lucene.Net.Index.Term) Lucene.Net.Index.IndexReader.AddReaderClosedListener(Lucene.Net.Index.IndexReader.IReaderClosedListener) Lucene.Net.Index.IndexReader.RemoveReaderClosedListener(Lucene.Net.Index.IndexReader.IReaderClosedListener) Lucene.Net.Index.IndexReader.RegisterParentReader(Lucene.Net.Index.IndexReader) Lucene.Net.Index.IndexReader.RefCount Lucene.Net.Index.IndexReader.IncRef() Lucene.Net.Index.IndexReader.TryIncRef() Lucene.Net.Index.IndexReader.DecRef() Lucene.Net.Index.IndexReader.EnsureOpen() IndexReader.Equals(Object) Lucene.Net.Index.IndexReader.GetHashCode() Lucene.Net.Index.IndexReader.Open(Lucene.Net.Store.Directory) IndexReader.Open(Directory, Int32) IndexReader.Open(IndexWriter, Boolean) Lucene.Net.Index.IndexReader.Open(Lucene.Net.Index.IndexCommit) IndexReader.Open(IndexCommit, Int32) IndexReader.GetTermVector(Int32, String) Lucene.Net.Index.IndexReader.NumDeletedDocs IndexReader.Document(Int32) IndexReader.Document(Int32, ISet<String>) Lucene.Net.Index.IndexReader.HasDeletions Lucene.Net.Index.IndexReader.Dispose() IndexReader.Dispose(Boolean) Lucene.Net.Index.IndexReader.Leaves Lucene.Net.Index.IndexReader.CoreCacheKey Lucene.Net.Index.IndexReader.CombinedCoreAndDeletesKey System.Object.Equals(System.Object, System.Object) System.Object.GetType() System.Object.MemberwiseClone() System.Object.ReferenceEquals(System.Object, System.Object) Namespace : Lucene.Net.Index.Sorter Assembly : Lucene.Net.Misc.dll Syntax public class SortingAtomicReader : FilterAtomicReader, IDisposable Properties | Improve this Doc View Source Fields Declaration public override Fields Fields { get; } Property Value Type Description Lucene.Net.Index.Fields Overrides Lucene.Net.Index.FilterAtomicReader.Fields | Improve this Doc View Source LiveDocs Declaration public override IBits LiveDocs { get; } Property Value Type Description Lucene.Net.Util.IBits Overrides Lucene.Net.Index.FilterAtomicReader.LiveDocs Methods | Improve this Doc View Source Document(Int32, StoredFieldVisitor) Declaration public override void Document(int docID, StoredFieldVisitor visitor) Parameters Type Name Description System.Int32 docID Lucene.Net.Index.StoredFieldVisitor visitor Overrides FilterAtomicReader.Document(Int32, StoredFieldVisitor) | Improve this Doc View Source GetBinaryDocValues(String) Declaration public override BinaryDocValues GetBinaryDocValues(string field) Parameters Type Name Description System.String field Returns Type Description Lucene.Net.Index.BinaryDocValues Overrides FilterAtomicReader.GetBinaryDocValues(String) | Improve this Doc View Source GetDocsWithField(String) Declaration public override IBits GetDocsWithField(string field) Parameters Type Name Description System.String field Returns Type Description Lucene.Net.Util.IBits Overrides FilterAtomicReader.GetDocsWithField(String) | Improve this Doc View Source GetNormValues(String) Declaration public override NumericDocValues GetNormValues(string field) Parameters Type Name Description System.String field Returns Type Description Lucene.Net.Index.NumericDocValues Overrides FilterAtomicReader.GetNormValues(String) | Improve this Doc View Source GetNumericDocValues(String) Declaration public override NumericDocValues GetNumericDocValues(string field) Parameters Type Name Description System.String field Returns Type Description Lucene.Net.Index.NumericDocValues Overrides FilterAtomicReader.GetNumericDocValues(String) | Improve this Doc View Source GetSortedDocValues(String) Declaration public override SortedDocValues GetSortedDocValues(string field) Parameters Type Name Description System.String field Returns Type Description Lucene.Net.Index.SortedDocValues Overrides FilterAtomicReader.GetSortedDocValues(String) | Improve this Doc View Source GetSortedSetDocValues(String) Declaration public override SortedSetDocValues GetSortedSetDocValues(string field) Parameters Type Name Description System.String field Returns Type Description Lucene.Net.Index.SortedSetDocValues Overrides FilterAtomicReader.GetSortedSetDocValues(String) | Improve this Doc View Source GetTermVectors(Int32) Declaration public override Fields GetTermVectors(int docID) Parameters Type Name Description System.Int32 docID Returns Type Description Lucene.Net.Index.Fields Overrides FilterAtomicReader.GetTermVectors(Int32) | Improve this Doc View Source Wrap(AtomicReader, Sort) Return a sorted view of reader according to the order defined by sort . If the reader is already sorted, this method might return the reader as-is. Declaration public static AtomicReader Wrap(AtomicReader reader, Sort sort) Parameters Type Name Description Lucene.Net.Index.AtomicReader reader Lucene.Net.Search.Sort sort Returns Type Description Lucene.Net.Index.AtomicReader Implements System.IDisposable"
  },
  "Lucene.Net.Index.Sorter.SortingMergePolicy.html": {
    "href": "Lucene.Net.Index.Sorter.SortingMergePolicy.html",
    "title": "Class SortingMergePolicy | Apache Lucene.NET 4.8.0-beta00013 Documentation",
    "keywords": "Class SortingMergePolicy A Lucene.Net.Index.MergePolicy that reorders documents according to a Lucene.Net.Search.Sort before merging them. As a consequence, all segments resulting from a merge will be sorted while segments resulting from a flush will be in the order in which documents have been added. NOTE : Never use this policy if you rely on AddDocuments(IEnumerable<IEnumerable<IIndexableField>>, Analyzer) to have sequentially-assigned doc IDs, this policy will scatter doc IDs. NOTE : This policy should only be used with idempotent Lucene.Net.Search.Sort s so that the order of segments is predictable. For example, using INDEXORDER in reverse (which is not idempotent) will make the order of documents in a segment depend on the number of times the segment has been merged. This is a Lucene.NET EXPERIMENTAL API, use at your own risk Inheritance System.Object Lucene.Net.Index.MergePolicy SortingMergePolicy Implements System.IDisposable Inherited Members Lucene.Net.Index.MergePolicy.DEFAULT_NO_CFS_RATIO Lucene.Net.Index.MergePolicy.DEFAULT_MAX_CFS_SEGMENT_SIZE Lucene.Net.Index.MergePolicy.m_writer Lucene.Net.Index.MergePolicy.m_noCFSRatio Lucene.Net.Index.MergePolicy.m_maxCFSSegmentSize Lucene.Net.Index.MergePolicy.Dispose() Lucene.Net.Index.MergePolicy.Size(Lucene.Net.Index.SegmentCommitInfo) Lucene.Net.Index.MergePolicy.IsMerged(Lucene.Net.Index.SegmentInfos, Lucene.Net.Index.SegmentCommitInfo) Lucene.Net.Index.MergePolicy.NoCFSRatio Lucene.Net.Index.MergePolicy.MaxCFSSegmentSizeMB System.Object.Equals(System.Object) System.Object.Equals(System.Object, System.Object) System.Object.GetHashCode() System.Object.GetType() System.Object.MemberwiseClone() System.Object.ReferenceEquals(System.Object, System.Object) Namespace : Lucene.Net.Index.Sorter Assembly : Lucene.Net.Misc.dll Syntax public sealed class SortingMergePolicy : MergePolicy, IDisposable Constructors | Improve this Doc View Source SortingMergePolicy(MergePolicy, Sort) Create a new Lucene.Net.Index.MergePolicy that sorts documents with the given sort . Declaration public SortingMergePolicy(MergePolicy in, Sort sort) Parameters Type Name Description Lucene.Net.Index.MergePolicy in Lucene.Net.Search.Sort sort Fields | Improve this Doc View Source SORTER_ID_PROP Put in the Diagnostics to denote that this segment is sorted. Declaration public static readonly string SORTER_ID_PROP Field Value Type Description System.String Methods | Improve this Doc View Source Clone() Declaration public override object Clone() Returns Type Description System.Object Overrides Lucene.Net.Index.MergePolicy.Clone() | Improve this Doc View Source Dispose(Boolean) Declaration protected override void Dispose(bool disposing) Parameters Type Name Description System.Boolean disposing Overrides MergePolicy.Dispose(Boolean) | Improve this Doc View Source FindForcedDeletesMerges(SegmentInfos) Declaration public override MergePolicy.MergeSpecification FindForcedDeletesMerges(SegmentInfos segmentInfos) Parameters Type Name Description Lucene.Net.Index.SegmentInfos segmentInfos Returns Type Description Lucene.Net.Index.MergePolicy.MergeSpecification Overrides Lucene.Net.Index.MergePolicy.FindForcedDeletesMerges(Lucene.Net.Index.SegmentInfos) | Improve this Doc View Source FindForcedMerges(SegmentInfos, Int32, IDictionary<SegmentCommitInfo, Nullable<Boolean>>) Declaration public override MergePolicy.MergeSpecification FindForcedMerges(SegmentInfos segmentInfos, int maxSegmentCount, IDictionary<SegmentCommitInfo, bool?> segmentsToMerge) Parameters Type Name Description Lucene.Net.Index.SegmentInfos segmentInfos System.Int32 maxSegmentCount System.Collections.Generic.IDictionary < Lucene.Net.Index.SegmentCommitInfo , System.Nullable < System.Boolean >> segmentsToMerge Returns Type Description Lucene.Net.Index.MergePolicy.MergeSpecification Overrides MergePolicy.FindForcedMerges(SegmentInfos, Int32, IDictionary<SegmentCommitInfo, Nullable<Boolean>>) | Improve this Doc View Source FindMerges(MergeTrigger, SegmentInfos) Declaration public override MergePolicy.MergeSpecification FindMerges(MergeTrigger mergeTrigger, SegmentInfos segmentInfos) Parameters Type Name Description Lucene.Net.Index.MergeTrigger mergeTrigger Lucene.Net.Index.SegmentInfos segmentInfos Returns Type Description Lucene.Net.Index.MergePolicy.MergeSpecification Overrides Lucene.Net.Index.MergePolicy.FindMerges(Lucene.Net.Index.MergeTrigger, Lucene.Net.Index.SegmentInfos) | Improve this Doc View Source IsSorted(AtomicReader, Sort) Returns true if the given reader is sorted by the specified sort . Declaration public static bool IsSorted(AtomicReader reader, Sort sort) Parameters Type Name Description Lucene.Net.Index.AtomicReader reader Lucene.Net.Search.Sort sort Returns Type Description System.Boolean | Improve this Doc View Source SetIndexWriter(IndexWriter) Declaration public override void SetIndexWriter(IndexWriter writer) Parameters Type Name Description Lucene.Net.Index.IndexWriter writer Overrides Lucene.Net.Index.MergePolicy.SetIndexWriter(Lucene.Net.Index.IndexWriter) | Improve this Doc View Source ToString() Declaration public override string ToString() Returns Type Description System.String Overrides System.Object.ToString() | Improve this Doc View Source UseCompoundFile(SegmentInfos, SegmentCommitInfo) Declaration public override bool UseCompoundFile(SegmentInfos segments, SegmentCommitInfo newSegment) Parameters Type Name Description Lucene.Net.Index.SegmentInfos segments Lucene.Net.Index.SegmentCommitInfo newSegment Returns Type Description System.Boolean Overrides Lucene.Net.Index.MergePolicy.UseCompoundFile(Lucene.Net.Index.SegmentInfos, Lucene.Net.Index.SegmentCommitInfo) Implements System.IDisposable"
  },
  "Lucene.Net.Misc.GetTermInfo.html": {
    "href": "Lucene.Net.Misc.GetTermInfo.html",
    "title": "Class GetTermInfo | Apache Lucene.NET 4.8.0-beta00013 Documentation",
    "keywords": "Class GetTermInfo Utility to get document frequency and total number of occurrences (sum of the tf for each doc) of a term. Inheritance System.Object GetTermInfo Inherited Members System.Object.Equals(System.Object) System.Object.Equals(System.Object, System.Object) System.Object.GetHashCode() System.Object.GetType() System.Object.MemberwiseClone() System.Object.ReferenceEquals(System.Object, System.Object) System.Object.ToString() Namespace : Lucene.Net.Misc Assembly : Lucene.Net.Misc.dll Syntax public static class GetTermInfo Methods | Improve this Doc View Source Main(String[]) Declaration public static void Main(string[] args) Parameters Type Name Description System.String [] args | Improve this Doc View Source TermInfo(Directory, Term) Declaration public static void TermInfo(Directory dir, Term term) Parameters Type Name Description Lucene.Net.Store.Directory dir Lucene.Net.Index.Term term"
  },
  "Lucene.Net.Misc.HighFreqTerms.DocFreqComparer.html": {
    "href": "Lucene.Net.Misc.HighFreqTerms.DocFreqComparer.html",
    "title": "Class HighFreqTerms.DocFreqComparer | Apache Lucene.NET 4.8.0-beta00013 Documentation",
    "keywords": "Class HighFreqTerms.DocFreqComparer Compares terms by DocFreq Inheritance System.Object HighFreqTerms.DocFreqComparer Implements System.Collections.Generic.IComparer < TermStats > Inherited Members System.Object.Equals(System.Object) System.Object.Equals(System.Object, System.Object) System.Object.GetHashCode() System.Object.GetType() System.Object.MemberwiseClone() System.Object.ReferenceEquals(System.Object, System.Object) System.Object.ToString() Namespace : Lucene.Net.Misc Assembly : Lucene.Net.Misc.dll Syntax public sealed class DocFreqComparer : IComparer<TermStats> Methods | Improve this Doc View Source Compare(TermStats, TermStats) Declaration public int Compare(TermStats a, TermStats b) Parameters Type Name Description TermStats a TermStats b Returns Type Description System.Int32 Implements System.Collections.Generic.IComparer<T>"
  },
  "Lucene.Net.Misc.HighFreqTerms.html": {
    "href": "Lucene.Net.Misc.HighFreqTerms.html",
    "title": "Class HighFreqTerms | Apache Lucene.NET 4.8.0-beta00013 Documentation",
    "keywords": "Class HighFreqTerms HighFreqTerms class extracts the top n most frequent terms (by document frequency) from an existing Lucene index and reports their document frequency. If the -t flag is given, both document frequency and total tf (total number of occurrences) are reported, ordered by descending total tf. Inheritance System.Object HighFreqTerms Inherited Members System.Object.Equals(System.Object) System.Object.Equals(System.Object, System.Object) System.Object.GetHashCode() System.Object.GetType() System.Object.MemberwiseClone() System.Object.ReferenceEquals(System.Object, System.Object) System.Object.ToString() Namespace : Lucene.Net.Misc Assembly : Lucene.Net.Misc.dll Syntax public static class HighFreqTerms Fields | Improve this Doc View Source DEFAULT_NUMTERMS Declaration public const int DEFAULT_NUMTERMS = 100 Field Value Type Description System.Int32 Methods | Improve this Doc View Source GetHighFreqTerms(IndexReader, Int32, String, IComparer<TermStats>) Returns TermStats[] ordered by the specified comparer Declaration public static TermStats[] GetHighFreqTerms(IndexReader reader, int numTerms, string field, IComparer<TermStats> comparer) Parameters Type Name Description Lucene.Net.Index.IndexReader reader System.Int32 numTerms System.String field System.Collections.Generic.IComparer < TermStats > comparer Returns Type Description TermStats [] | Improve this Doc View Source Main(String[]) Declaration public static void Main(string[] args) Parameters Type Name Description System.String [] args"
  },
  "Lucene.Net.Misc.HighFreqTerms.TotalTermFreqComparer.html": {
    "href": "Lucene.Net.Misc.HighFreqTerms.TotalTermFreqComparer.html",
    "title": "Class HighFreqTerms.TotalTermFreqComparer | Apache Lucene.NET 4.8.0-beta00013 Documentation",
    "keywords": "Class HighFreqTerms.TotalTermFreqComparer Compares terms by TotalTermFreq Inheritance System.Object HighFreqTerms.TotalTermFreqComparer Implements System.Collections.Generic.IComparer < TermStats > Inherited Members System.Object.Equals(System.Object) System.Object.Equals(System.Object, System.Object) System.Object.GetHashCode() System.Object.GetType() System.Object.MemberwiseClone() System.Object.ReferenceEquals(System.Object, System.Object) System.Object.ToString() Namespace : Lucene.Net.Misc Assembly : Lucene.Net.Misc.dll Syntax public sealed class TotalTermFreqComparer : IComparer<TermStats> Methods | Improve this Doc View Source Compare(TermStats, TermStats) Declaration public int Compare(TermStats a, TermStats b) Parameters Type Name Description TermStats a TermStats b Returns Type Description System.Int32 Implements System.Collections.Generic.IComparer<T>"
  },
  "Lucene.Net.Misc.html": {
    "href": "Lucene.Net.Misc.html",
    "title": "Namespace Lucene.Net.Misc | Apache Lucene.NET 4.8.0-beta00013 Documentation",
    "keywords": "Namespace Lucene.Net.Misc <!-- Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. --> Misc Tools The misc package has various tools for splitting/merging indices, changing norms, finding high freq terms, and others. NativeUnixDirectory NOTE : This uses C++ sources (accessible via JNI), which you'll have to compile on your platform. <xref:Lucene.Net.Store.NativeUnixDirectory> is a Directory implementation that bypasses the OS's buffer cache (using direct IO) for any IndexInput and IndexOutput used during merging of segments larger than a specified size (default 10 MB). This avoids evicting hot pages that are still in-use for searching, keeping search more responsive while large merges run. See this blog post for details. Steps to build: cd lucene/misc/ To compile NativePosixUtil.cpp -> libNativePosixUtil.so, run ant build-native-unix . libNativePosixUtil.so will be located in the lucene/build/native/ folder Make sure libNativePosixUtil.so is on your LD_LIBRARY_PATH so java can find it (something like export LD_LIBRARY_PATH=/path/to/dir:$LD_LIBRARY_PATH , where /path/to/dir contains libNativePosixUtil.so) ant jar to compile the java source and put that JAR on your CLASSPATH NativePosixUtil.cpp/java also expose access to the posix_madvise, madvise, posix_fadvise functions, which are somewhat more cross platform than O_DIRECT, however, in testing (see above link), these APIs did not seem to help prevent buffer cache eviction. Classes GetTermInfo Utility to get document frequency and total number of occurrences (sum of the tf for each doc) of a term. HighFreqTerms HighFreqTerms class extracts the top n most frequent terms (by document frequency) from an existing Lucene index and reports their document frequency. If the -t flag is given, both document frequency and total tf (total number of occurrences) are reported, ordered by descending total tf. HighFreqTerms.DocFreqComparer Compares terms by DocFreq HighFreqTerms.TotalTermFreqComparer Compares terms by TotalTermFreq IndexMergeTool Merges indices specified on the command line into the index specified as the first command line argument. SweetSpotSimilarity A similarity with a lengthNorm that provides for a \"plateau\" of equally good lengths, and tf helper functions. For lengthNorm, A min/max can be specified to define the plateau of lengths that should all have a norm of 1.0. Below the min, and above the max the lengthNorm drops off in a sqrt function. For tf, baselineTf and hyperbolicTf functions are provided, which subclasses can choose between. TermStats Holder for a term along with its statistics ( DocFreq and TotalTermFreq )."
  },
  "Lucene.Net.Misc.IndexMergeTool.html": {
    "href": "Lucene.Net.Misc.IndexMergeTool.html",
    "title": "Class IndexMergeTool | Apache Lucene.NET 4.8.0-beta00013 Documentation",
    "keywords": "Class IndexMergeTool Merges indices specified on the command line into the index specified as the first command line argument. Inheritance System.Object IndexMergeTool Inherited Members System.Object.Equals(System.Object) System.Object.Equals(System.Object, System.Object) System.Object.GetHashCode() System.Object.GetType() System.Object.MemberwiseClone() System.Object.ReferenceEquals(System.Object, System.Object) System.Object.ToString() Namespace : Lucene.Net.Misc Assembly : Lucene.Net.Misc.dll Syntax public static class IndexMergeTool Methods | Improve this Doc View Source Main(String[]) Declaration public static void Main(string[] args) Parameters Type Name Description System.String [] args"
  },
  "Lucene.Net.Misc.SweetSpotSimilarity.html": {
    "href": "Lucene.Net.Misc.SweetSpotSimilarity.html",
    "title": "Class SweetSpotSimilarity | Apache Lucene.NET 4.8.0-beta00013 Documentation",
    "keywords": "Class SweetSpotSimilarity A similarity with a lengthNorm that provides for a \"plateau\" of equally good lengths, and tf helper functions. For lengthNorm, A min/max can be specified to define the plateau of lengths that should all have a norm of 1.0. Below the min, and above the max the lengthNorm drops off in a sqrt function. For tf, baselineTf and hyperbolicTf functions are provided, which subclasses can choose between. Inheritance System.Object Lucene.Net.Search.Similarities.Similarity Lucene.Net.Search.Similarities.TFIDFSimilarity Lucene.Net.Search.Similarities.DefaultSimilarity SweetSpotSimilarity Inherited Members DefaultSimilarity.Coord(Int32, Int32) DefaultSimilarity.QueryNorm(Single) DefaultSimilarity.EncodeNormValue(Single) DefaultSimilarity.DecodeNormValue(Int64) DefaultSimilarity.SloppyFreq(Int32) DefaultSimilarity.ScorePayload(Int32, Int32, Int32, BytesRef) DefaultSimilarity.Idf(Int64, Int64) Lucene.Net.Search.Similarities.DefaultSimilarity.m_discountOverlaps Lucene.Net.Search.Similarities.DefaultSimilarity.DiscountOverlaps Lucene.Net.Search.Similarities.DefaultSimilarity.ToString() Lucene.Net.Search.Similarities.TFIDFSimilarity.IdfExplain(Lucene.Net.Search.CollectionStatistics, Lucene.Net.Search.TermStatistics) Lucene.Net.Search.Similarities.TFIDFSimilarity.IdfExplain(Lucene.Net.Search.CollectionStatistics, Lucene.Net.Search.TermStatistics[]) Lucene.Net.Search.Similarities.TFIDFSimilarity.ComputeNorm(Lucene.Net.Index.FieldInvertState) TFIDFSimilarity.ComputeWeight(Single, CollectionStatistics, TermStatistics[]) Lucene.Net.Search.Similarities.TFIDFSimilarity.GetSimScorer(Lucene.Net.Search.Similarities.Similarity.SimWeight, Lucene.Net.Index.AtomicReaderContext) System.Object.Equals(System.Object) System.Object.Equals(System.Object, System.Object) System.Object.GetHashCode() System.Object.GetType() System.Object.MemberwiseClone() System.Object.ReferenceEquals(System.Object, System.Object) Namespace : Lucene.Net.Misc Assembly : Lucene.Net.Misc.dll Syntax public class SweetSpotSimilarity : DefaultSimilarity Constructors | Improve this Doc View Source SweetSpotSimilarity() Declaration public SweetSpotSimilarity() Methods | Improve this Doc View Source BaselineTf(Single) Implemented as: (x <= min) ? base : Math.Sqrt(x+(base**2)-min) ...but with a special case check for 0. This degrates to Math.Sqrt(x) when min and base are both 0 Declaration public virtual float BaselineTf(float freq) Parameters Type Name Description System.Single freq Returns Type Description System.Single See Also SetBaselineTfFactors(Single, Single) | Improve this Doc View Source ComputeLengthNorm(Int32) Implemented as: 1/sqrt( steepness * (Math.Abs(x-min) + Math.Abs(x-max) - (max-min)) + 1 ) . This degrades to 1/Math.Sqrt(x) when min and max are both 1 and steepness is 0.5 :TODO: potential optimization is to just flat out return 1.0f if numTerms is between min and max. Declaration public virtual float ComputeLengthNorm(int numTerms) Parameters Type Name Description System.Int32 numTerms Returns Type Description System.Single See Also SetLengthNormFactors(Int32, Int32, Single, Boolean) | Improve this Doc View Source HyperbolicTf(Single) Uses a hyperbolic tangent function that allows for a hard max... tf(x)=min+(max-min)/2*(((base**(x-xoffset)-base**-(x-xoffset))/(base**(x-xoffset)+base**-(x-xoffset)))+1) This code is provided as a convenience for subclasses that want to use a hyperbolic tf function. Declaration public virtual float HyperbolicTf(float freq) Parameters Type Name Description System.Single freq Returns Type Description System.Single See Also SetHyperbolicTfFactors(Single, Single, Double, Single) | Improve this Doc View Source LengthNorm(FieldInvertState) Implemented as state.Boost * ComputeLengthNorm(numTokens) where numTokens does not count overlap tokens if discountOverlaps is true by default or true for this specific field. Declaration public override float LengthNorm(FieldInvertState state) Parameters Type Name Description Lucene.Net.Index.FieldInvertState state Returns Type Description System.Single Overrides Lucene.Net.Search.Similarities.DefaultSimilarity.LengthNorm(Lucene.Net.Index.FieldInvertState) | Improve this Doc View Source SetBaselineTfFactors(Single, Single) Sets the baseline and minimum function variables for baselineTf Declaration public virtual void SetBaselineTfFactors(float base, float min) Parameters Type Name Description System.Single base System.Single min See Also BaselineTf(Single) | Improve this Doc View Source SetHyperbolicTfFactors(Single, Single, Double, Single) Sets the function variables for the hyperbolicTf functions Declaration public virtual void SetHyperbolicTfFactors(float min, float max, double base, float xoffset) Parameters Type Name Description System.Single min the minimum tf value to ever be returned (default: 0.0) System.Single max the maximum tf value to ever be returned (default: 2.0) System.Double base the base value to be used in the exponential for the hyperbolic function (default: 1.3) System.Single xoffset the midpoint of the hyperbolic function (default: 10.0) See Also HyperbolicTf(Single) | Improve this Doc View Source SetLengthNormFactors(Int32, Int32, Single, Boolean) Sets the default function variables used by lengthNorm when no field specific variables have been set. Declaration public virtual void SetLengthNormFactors(int min, int max, float steepness, bool discountOverlaps) Parameters Type Name Description System.Int32 min System.Int32 max System.Single steepness System.Boolean discountOverlaps See Also ComputeLengthNorm(Int32) | Improve this Doc View Source Tf(Single) Delegates to baselineTf Declaration public override float Tf(float freq) Parameters Type Name Description System.Single freq Returns Type Description System.Single Overrides DefaultSimilarity.Tf(Single) See Also BaselineTf(Single)"
  },
  "Lucene.Net.Misc.TermStats.html": {
    "href": "Lucene.Net.Misc.TermStats.html",
    "title": "Class TermStats | Apache Lucene.NET 4.8.0-beta00013 Documentation",
    "keywords": "Class TermStats Holder for a term along with its statistics ( DocFreq and TotalTermFreq ). Inheritance System.Object TermStats Inherited Members System.Object.Equals(System.Object) System.Object.Equals(System.Object, System.Object) System.Object.GetHashCode() System.Object.GetType() System.Object.MemberwiseClone() System.Object.ReferenceEquals(System.Object, System.Object) Namespace : Lucene.Net.Misc Assembly : Lucene.Net.Misc.dll Syntax public sealed class TermStats Properties | Improve this Doc View Source DocFreq Declaration public int DocFreq { get; set; } Property Value Type Description System.Int32 | Improve this Doc View Source Field Declaration public string Field { get; set; } Property Value Type Description System.String | Improve this Doc View Source TotalTermFreq Declaration public long TotalTermFreq { get; set; } Property Value Type Description System.Int64 Methods | Improve this Doc View Source ToString() Declaration public override string ToString() Returns Type Description System.String Overrides System.Object.ToString()"
  },
  "Lucene.Net.Util.Fst.html": {
    "href": "Lucene.Net.Util.Fst.html",
    "title": "Namespace Lucene.Net.Util.Fst | Apache Lucene.NET 4.8.0-beta00013 Documentation",
    "keywords": "Namespace Lucene.Net.Util.Fst <!-- Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file distributed with this work for additional information regarding copyright ownership. The ASF licenses this file to You under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. --> Misc FST classes. Classes ListOfOutputs<T> Wraps another Outputs implementation and encodes one or more of its output values. You can use this when a single input may need to map to more than one output, maintaining order: pass the same input with a different output by calling Add(Int32sRef, T) multiple times. The builder will then combine the outputs using the Lucene.Net.Util.Fst.Outputs<T>.Merge(T, T) method. The resulting FST may not be minimal when an input has more than one output, as this requires pushing all multi-output values to a final state. NOTE: the only way to create multiple outputs is to add the same input to the FST multiple times in a row. This is how the FST maps a single input to multiple outputs (e.g. you cannot pass a List<Object> to Add(Int32sRef, T) ). If your outputs are longs, and you need at most 2, then use UpToTwoPositiveInt64Outputs instead since it stores the outputs more compactly (by stealing a bit from each long value). NOTE: this cannot wrap itself (ie you cannot make an FST with List<List<Object>> outputs using this). @lucene.experimental UpToTwoPositiveInt64Outputs An FST Lucene.Net.Util.Fst.Outputs<T> implementation where each output is one or two non-negative long values. If it's a System.Single output, System.Nullable<T> is returned; else, UpToTwoPositiveInt64Outputs.TwoInt64s . Order is preserved in the UpToTwoPositiveInt64Outputs.TwoInt64s case, ie .first is the first input/output added to Builder<T> , and .second is the second. You cannot store 0 output with this (that's reserved to mean \"no output\")! NOTE: the only way to create a TwoLongs output is to add the same input to the FST twice in a row. This is how the FST maps a single input to two outputs (e.g. you cannot pass a UpToTwoPositiveInt64Outputs.TwoInt64s to Add(Int32sRef, T) . If you need more than two then use ListOfOutputs<T> , but if you only have at most 2 then this implementation will require fewer bytes as it steals one bit from each long value. NOTE: the resulting FST is not guaranteed to be minimal! See Builder<T> . NOTE: This was UpToTwoPositiveIntOutputs in Lucene - the data type (int) was wrong there - it should have been long This is a Lucene.NET EXPERIMENTAL API, use at your own risk UpToTwoPositiveInt64Outputs.TwoInt64s Holds two long outputs. NOTE: This was TwoLongs in Lucene"
  },
  "Lucene.Net.Util.Fst.ListOfOutputs-1.html": {
    "href": "Lucene.Net.Util.Fst.ListOfOutputs-1.html",
    "title": "Class ListOfOutputs<T> | Apache Lucene.NET 4.8.0-beta00013 Documentation",
    "keywords": "Class ListOfOutputs<T> Wraps another Outputs implementation and encodes one or more of its output values. You can use this when a single input may need to map to more than one output, maintaining order: pass the same input with a different output by calling Add(Int32sRef, T) multiple times. The builder will then combine the outputs using the Lucene.Net.Util.Fst.Outputs<T>.Merge(T, T) method. The resulting FST may not be minimal when an input has more than one output, as this requires pushing all multi-output values to a final state. NOTE: the only way to create multiple outputs is to add the same input to the FST multiple times in a row. This is how the FST maps a single input to multiple outputs (e.g. you cannot pass a List<Object> to Add(Int32sRef, T) ). If your outputs are longs, and you need at most 2, then use UpToTwoPositiveInt64Outputs instead since it stores the outputs more compactly (by stealing a bit from each long value). NOTE: this cannot wrap itself (ie you cannot make an FST with List<List<Object>> outputs using this). @lucene.experimental Inheritance System.Object Lucene.Net.Util.Fst.Outputs < System.Object > ListOfOutputs<T> Inherited Members System.Object.Equals(System.Object) System.Object.Equals(System.Object, System.Object) System.Object.GetHashCode() System.Object.GetType() System.Object.MemberwiseClone() System.Object.ReferenceEquals(System.Object, System.Object) Namespace : Lucene.Net.Util.Fst Assembly : Lucene.Net.Misc.dll Syntax public sealed class ListOfOutputs<T> : Outputs<object> Type Parameters Name Description T Constructors | Improve this Doc View Source ListOfOutputs(Outputs<T>) Declaration public ListOfOutputs(Outputs<T> outputs) Parameters Type Name Description Lucene.Net.Util.Fst.Outputs <T> outputs Properties | Improve this Doc View Source NoOutput Declaration public override object NoOutput { get; } Property Value Type Description System.Object Overrides Lucene.Net.Util.Fst.Outputs<System.Object>.NoOutput Methods | Improve this Doc View Source Add(Object, Object) Declaration public override object Add(object prefix, object output) Parameters Type Name Description System.Object prefix System.Object output Returns Type Description System.Object Overrides Lucene.Net.Util.Fst.Outputs<System.Object>.Add(System.Object, System.Object) | Improve this Doc View Source AsList(Object) Declaration public IList<T> AsList(object output) Parameters Type Name Description System.Object output Returns Type Description System.Collections.Generic.IList <T> | Improve this Doc View Source Common(Object, Object) Declaration public override object Common(object output1, object output2) Parameters Type Name Description System.Object output1 System.Object output2 Returns Type Description System.Object Overrides Lucene.Net.Util.Fst.Outputs<System.Object>.Common(System.Object, System.Object) | Improve this Doc View Source Merge(Object, Object) Declaration public override object Merge(object first, object second) Parameters Type Name Description System.Object first System.Object second Returns Type Description System.Object Overrides Lucene.Net.Util.Fst.Outputs<System.Object>.Merge(System.Object, System.Object) | Improve this Doc View Source OutputToString(Object) Declaration public override string OutputToString(object output) Parameters Type Name Description System.Object output Returns Type Description System.String Overrides Lucene.Net.Util.Fst.Outputs<System.Object>.OutputToString(System.Object) | Improve this Doc View Source Read(DataInput) Declaration public override object Read(DataInput in) Parameters Type Name Description Lucene.Net.Store.DataInput in Returns Type Description System.Object Overrides Lucene.Net.Util.Fst.Outputs<System.Object>.Read(Lucene.Net.Store.DataInput) | Improve this Doc View Source ReadFinalOutput(DataInput) Declaration public override object ReadFinalOutput(DataInput in) Parameters Type Name Description Lucene.Net.Store.DataInput in Returns Type Description System.Object Overrides Lucene.Net.Util.Fst.Outputs<System.Object>.ReadFinalOutput(Lucene.Net.Store.DataInput) | Improve this Doc View Source Subtract(Object, Object) Declaration public override object Subtract(object object, object inc) Parameters Type Name Description System.Object object System.Object inc Returns Type Description System.Object Overrides Lucene.Net.Util.Fst.Outputs<System.Object>.Subtract(System.Object, System.Object) | Improve this Doc View Source ToString() Declaration public override string ToString() Returns Type Description System.String Overrides System.Object.ToString() | Improve this Doc View Source Write(Object, DataOutput) Declaration public override void Write(object output, DataOutput out) Parameters Type Name Description System.Object output Lucene.Net.Store.DataOutput out Overrides Lucene.Net.Util.Fst.Outputs<System.Object>.Write(System.Object, Lucene.Net.Store.DataOutput) | Improve this Doc View Source WriteFinalOutput(Object, DataOutput) Declaration public override void WriteFinalOutput(object output, DataOutput out) Parameters Type Name Description System.Object output Lucene.Net.Store.DataOutput out Overrides Lucene.Net.Util.Fst.Outputs<System.Object>.WriteFinalOutput(System.Object, Lucene.Net.Store.DataOutput)"
  },
  "Lucene.Net.Util.Fst.UpToTwoPositiveInt64Outputs.html": {
    "href": "Lucene.Net.Util.Fst.UpToTwoPositiveInt64Outputs.html",
    "title": "Class UpToTwoPositiveInt64Outputs | Apache Lucene.NET 4.8.0-beta00013 Documentation",
    "keywords": "Class UpToTwoPositiveInt64Outputs An FST Lucene.Net.Util.Fst.Outputs<T> implementation where each output is one or two non-negative long values. If it's a System.Single output, System.Nullable<T> is returned; else, UpToTwoPositiveInt64Outputs.TwoInt64s . Order is preserved in the UpToTwoPositiveInt64Outputs.TwoInt64s case, ie .first is the first input/output added to Builder<T> , and .second is the second. You cannot store 0 output with this (that's reserved to mean \"no output\")! NOTE: the only way to create a TwoLongs output is to add the same input to the FST twice in a row. This is how the FST maps a single input to two outputs (e.g. you cannot pass a UpToTwoPositiveInt64Outputs.TwoInt64s to Add(Int32sRef, T) . If you need more than two then use ListOfOutputs<T> , but if you only have at most 2 then this implementation will require fewer bytes as it steals one bit from each long value. NOTE: the resulting FST is not guaranteed to be minimal! See Builder<T> . NOTE: This was UpToTwoPositiveIntOutputs in Lucene - the data type (int) was wrong there - it should have been long This is a Lucene.NET EXPERIMENTAL API, use at your own risk Inheritance System.Object Lucene.Net.Util.Fst.Outputs < System.Object > UpToTwoPositiveInt64Outputs Inherited Members Lucene.Net.Util.Fst.Outputs<System.Object>.WriteFinalOutput(System.Object, Lucene.Net.Store.DataOutput) Lucene.Net.Util.Fst.Outputs<System.Object>.ReadFinalOutput(Lucene.Net.Store.DataInput) System.Object.Equals(System.Object) System.Object.Equals(System.Object, System.Object) System.Object.GetHashCode() System.Object.GetType() System.Object.MemberwiseClone() System.Object.ReferenceEquals(System.Object, System.Object) System.Object.ToString() Namespace : Lucene.Net.Util.Fst Assembly : Lucene.Net.Misc.dll Syntax public sealed class UpToTwoPositiveInt64Outputs : Outputs<object> Properties | Improve this Doc View Source NoOutput Declaration public override object NoOutput { get; } Property Value Type Description System.Object Overrides Lucene.Net.Util.Fst.Outputs<System.Object>.NoOutput Methods | Improve this Doc View Source Add(Object, Object) Declaration public override object Add(object prefix, object output) Parameters Type Name Description System.Object prefix System.Object output Returns Type Description System.Object Overrides Lucene.Net.Util.Fst.Outputs<System.Object>.Add(System.Object, System.Object) | Improve this Doc View Source Common(Object, Object) Declaration public override object Common(object output1, object output2) Parameters Type Name Description System.Object output1 System.Object output2 Returns Type Description System.Object Overrides Lucene.Net.Util.Fst.Outputs<System.Object>.Common(System.Object, System.Object) | Improve this Doc View Source Get(Int64) Declaration public long? Get(long v) Parameters Type Name Description System.Int64 v Returns Type Description System.Nullable < System.Int64 > | Improve this Doc View Source Get(Int64, Int64) Declaration public UpToTwoPositiveInt64Outputs.TwoInt64s Get(long first, long second) Parameters Type Name Description System.Int64 first System.Int64 second Returns Type Description UpToTwoPositiveInt64Outputs.TwoInt64s | Improve this Doc View Source GetSingleton(Boolean) Declaration public static UpToTwoPositiveInt64Outputs GetSingleton(bool doShare) Parameters Type Name Description System.Boolean doShare Returns Type Description UpToTwoPositiveInt64Outputs | Improve this Doc View Source Merge(Object, Object) Declaration public override object Merge(object first, object second) Parameters Type Name Description System.Object first System.Object second Returns Type Description System.Object Overrides Lucene.Net.Util.Fst.Outputs<System.Object>.Merge(System.Object, System.Object) | Improve this Doc View Source OutputToString(Object) Declaration public override string OutputToString(object output) Parameters Type Name Description System.Object output Returns Type Description System.String Overrides Lucene.Net.Util.Fst.Outputs<System.Object>.OutputToString(System.Object) | Improve this Doc View Source Read(DataInput) Declaration public override object Read(DataInput in) Parameters Type Name Description Lucene.Net.Store.DataInput in Returns Type Description System.Object Overrides Lucene.Net.Util.Fst.Outputs<System.Object>.Read(Lucene.Net.Store.DataInput) | Improve this Doc View Source Subtract(Object, Object) Declaration public override object Subtract(object output, object inc) Parameters Type Name Description System.Object output System.Object inc Returns Type Description System.Object Overrides Lucene.Net.Util.Fst.Outputs<System.Object>.Subtract(System.Object, System.Object) | Improve this Doc View Source Write(Object, DataOutput) Declaration public override void Write(object output, DataOutput out) Parameters Type Name Description System.Object output Lucene.Net.Store.DataOutput out Overrides Lucene.Net.Util.Fst.Outputs<System.Object>.Write(System.Object, Lucene.Net.Store.DataOutput)"
  },
  "Lucene.Net.Util.Fst.UpToTwoPositiveInt64Outputs.TwoInt64s.html": {
    "href": "Lucene.Net.Util.Fst.UpToTwoPositiveInt64Outputs.TwoInt64s.html",
    "title": "Class UpToTwoPositiveInt64Outputs.TwoInt64s | Apache Lucene.NET 4.8.0-beta00013 Documentation",
    "keywords": "Class UpToTwoPositiveInt64Outputs.TwoInt64s Holds two long outputs. NOTE: This was TwoLongs in Lucene Inheritance System.Object UpToTwoPositiveInt64Outputs.TwoInt64s Inherited Members System.Object.Equals(System.Object, System.Object) System.Object.GetType() System.Object.MemberwiseClone() System.Object.ReferenceEquals(System.Object, System.Object) Namespace : Lucene.Net.Util.Fst Assembly : Lucene.Net.Misc.dll Syntax public sealed class TwoInt64s Constructors | Improve this Doc View Source TwoInt64s(Int64, Int64) Declaration public TwoInt64s(long first, long second) Parameters Type Name Description System.Int64 first System.Int64 second Properties | Improve this Doc View Source First Declaration public long First { get; } Property Value Type Description System.Int64 | Improve this Doc View Source Second Declaration public long Second { get; } Property Value Type Description System.Int64 Methods | Improve this Doc View Source Equals(Object) Declaration public override bool Equals(object other) Parameters Type Name Description System.Object other Returns Type Description System.Boolean Overrides System.Object.Equals(System.Object) | Improve this Doc View Source GetHashCode() Declaration public override int GetHashCode() Returns Type Description System.Int32 Overrides System.Object.GetHashCode() | Improve this Doc View Source ToString() Declaration public override string ToString() Returns Type Description System.String Overrides System.Object.ToString()"
  }
}