/// <summary> Create a field by specifying its name, value and how it will /// be saved in the index. /// /// </summary> /// <param name="name">The name of the field /// </param> /// <param name="internName">Whether to .intern() name or not /// </param> /// <param name="value">The string to process /// </param> /// <param name="store">Whether <c>value</c> should be stored in the index /// </param> /// <param name="index">Whether the field should be indexed, and if so, if it should /// be tokenized before indexing /// </param> /// <param name="termVector">Whether term vector should be stored /// </param> /// <throws> NullPointerException if name or value is <c>null</c> </throws> /// <throws> IllegalArgumentException in any of the following situations: </throws> /// <summary> <list> /// <item>the field is neither stored nor indexed</item> /// <item>the field is not indexed but termVector is <c>TermVector.YES</c></item> /// </list> /// </summary> public Field(System.String name, bool internName, System.String value, Store store, Index index, TermVector termVector) { if (name == null) { throw new System.NullReferenceException("name cannot be null"); } if (value == null) { throw new System.NullReferenceException("value cannot be null"); } if (name.Length == 0 && value.Length == 0) { throw new System.ArgumentException("name and value cannot both be empty"); } if (index == Index.NO && store == Store.NO) { throw new System.ArgumentException("it doesn't make sense to have a field that " + "is neither indexed nor stored"); } if (index == Index.NO && termVector != TermVector.NO) { throw new System.ArgumentException("cannot store term vector information " + "for a field that is not indexed"); } if (internName) { // field names are optionally interned name = StringHelper.Intern(name); } this.internalName = name; this.fieldsData = value; this.internalIsStored = store.IsStored(); this.internalIsIndexed = index.IsIndexed(); this.internalIsTokenized = index.IsAnalyzed(); this.internalOmitNorms = index.OmitNorms(); if (index == Index.NO) { this.internalOmitTermFreqAndPositions = false; } this.internalIsBinary = false; SetStoreTermVector(termVector); }
internal static int DetectFieldType(IndexReader reader, System.String fieldKey) { System.String field = StringHelper.Intern(fieldKey); TermEnum enumerator = reader.Terms(new Term(field)); try { Term term = enumerator.Term(); if (term == null) { throw new System.SystemException("no terms in field " + field + " - cannot determine sort type"); } int ret = 0; if ((System.Object)term.Field() == (System.Object)field) { System.String termtext = term.Text().Trim(); int tmpI32; long tmpI64; float tmpF; if (System.Int32.TryParse(termtext, out tmpI32)) { ret = SortField.INT; } else if (System.Int64.TryParse(termtext, out tmpI64)) { ret = SortField.LONG; } else if (SupportClass.Single.TryParse(termtext, out tmpF)) { ret = SortField.FLOAT; } else { ret = SortField.STRING; } } else { throw new System.SystemException("field \"" + field + "\" does not appear to be indexed"); } return(ret); } finally { enumerator.Close(); } }
protected internal AbstractField(System.String name, Field.Store store, Field.Index index, Field.TermVector termVector) { if (name == null) { throw new System.NullReferenceException("name cannot be null"); } this.internalName = StringHelper.Intern(name); // field names are interned this.internalIsStored = store.IsStored(); this.internalIsIndexed = index.IsIndexed(); this.internalIsTokenized = index.IsAnalyzed(); this.internalOmitNorms = index.OmitNorms(); this.internalIsBinary = false; SetStoreTermVector(termVector); }
/// <summary> Create a stored field with binary value. Optionally the value may be compressed. /// /// </summary> /// <param name="name">The name of the field /// </param> /// <param name="value">The binary value /// </param> /// <param name="offset">Starting offset in value where this Field's bytes are /// </param> /// <param name="length">Number of bytes to use for this Field, starting at offset /// </param> /// <param name="store">How <code>value</code> should be stored (compressed or not) /// </param> /// <throws> IllegalArgumentException if store is <code>Store.NO</code> </throws> public Field(System.String name, byte[] value_Renamed, int offset, int length, Store store) { if (name == null) { throw new System.ArgumentException("name cannot be null"); } if (value_Renamed == null) { throw new System.ArgumentException("value cannot be null"); } this.name = StringHelper.Intern(name); // field names are interned fieldsData = value_Renamed; if (store == Store.YES) { isStored = true; isCompressed = false; } else if (store == Store.COMPRESS) { isStored = true; isCompressed = true; } else if (store == Store.NO) { throw new System.ArgumentException("binary values can't be unstored"); } else { throw new System.ArgumentException("unknown store parameter " + store); } isIndexed = false; isTokenized = false; omitTermFreqAndPositions = false; omitNorms = true; isBinary = true; binaryLength = length; binaryOffset = offset; SetStoreTermVector(TermVector.NO); }
public FieldForMerge(System.Object value_Renamed, FieldInfo fi, bool binary, bool compressed, bool tokenize) { this.isStored = true; this.fieldsData = value_Renamed; this.isCompressed = compressed; this.isBinary = binary; if (binary) { binaryLength = ((byte[])value_Renamed).Length; } this.isTokenized = tokenize; this.name = StringHelper.Intern(fi.name); this.isIndexed = fi.isIndexed; this.omitNorms = fi.omitNorms; this.omitTermFreqAndPositions = fi.omitTermFreqAndPositions; this.storeOffsetWithTermVector = fi.storeOffsetWithTermVector; this.storePositionWithTermVector = fi.storePositionWithTermVector; this.storeTermVector = fi.storeTermVector; }
internal NumericRangeQuery(string field, int precisionStep, int valSize, T?min, T?max, bool minInclusive, bool maxInclusive) { System.Diagnostics.Debug.Assert((valSize == 32 || valSize == 64)); if (precisionStep < 1) { throw new System.ArgumentException("precisionStep must be >=1"); } this.field = StringHelper.Intern(field); this.precisionStep = precisionStep; this.valSize = valSize; this.min = min; this.max = max; this.minInclusive = minInclusive; this.maxInclusive = maxInclusive; // For bigger precisionSteps this query likely // hits too many terms, so set to CONSTANT_SCORE_FILTER right off // (especially as the FilteredTermEnum is costly if wasted only for AUTO tests because it // creates new enums from IndexReader for each sub-range) switch (valSize) { case 64: RewriteMethod = (precisionStep > 6)?CONSTANT_SCORE_FILTER_REWRITE:CONSTANT_SCORE_AUTO_REWRITE_DEFAULT; break; case 32: RewriteMethod = (precisionStep > 8)?CONSTANT_SCORE_FILTER_REWRITE:CONSTANT_SCORE_AUTO_REWRITE_DEFAULT; break; default: // should never happen throw new System.ArgumentException("valSize must be 32 or 64"); } // shortcut if upper bound == lower bound if (min != null && min.Equals(max)) { RewriteMethod = CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE; } }
/// <summary> Create a tokenized and indexed field that is not stored, optionally with /// storing term vectors. The Reader is read only when the Document is added to the index, /// i.e. you may not close the Reader until <see cref="IndexWriter.AddDocument(Document)" /> /// has been called. /// /// </summary> /// <param name="name">The name of the field /// </param> /// <param name="reader">The reader with the content /// </param> /// <param name="termVector">Whether term vector should be stored /// </param> /// <throws> NullPointerException if name or reader is <c>null</c> </throws> public Field(System.String name, System.IO.TextReader reader, TermVector termVector) { if (name == null) { throw new System.NullReferenceException("name cannot be null"); } if (reader == null) { throw new System.NullReferenceException("reader cannot be null"); } this.internalName = StringHelper.Intern(name); // field names are interned this.fieldsData = reader; this.internalIsStored = false; this.internalIsIndexed = true; this.internalIsTokenized = true; this.internalIsBinary = false; SetStoreTermVector(termVector); }
/// <summary> Create a tokenized and indexed field that is not stored, optionally with /// storing term vectors. This is useful for pre-analyzed fields. /// The TokenStream is read only when the Document is added to the index, /// i.e. you may not close the TokenStream until <see cref="IndexWriter.AddDocument(Document)" /> /// has been called. /// /// </summary> /// <param name="name">The name of the field /// </param> /// <param name="tokenStream">The TokenStream with the content /// </param> /// <param name="termVector">Whether term vector should be stored /// </param> /// <throws> NullPointerException if name or tokenStream is <c>null</c> </throws> public Field(System.String name, TokenStream tokenStream, TermVector termVector) { if (name == null) { throw new System.NullReferenceException("name cannot be null"); } if (tokenStream == null) { throw new System.NullReferenceException("tokenStream cannot be null"); } this.internalName = StringHelper.Intern(name); // field names are interned this.fieldsData = null; this.tokenStream = tokenStream; this.internalIsStored = false; this.internalIsIndexed = true; this.internalIsTokenized = true; this.internalIsBinary = false; SetStoreTermVector(termVector); }
/// <summary> Create a field by specifying its name, value and how it will /// be saved in the index. /// /// </summary> /// <param name="name">The name of the field /// </param> /// <param name="internName">Whether to .intern() name or not /// </param> /// <param name="value">The string to process /// </param> /// <param name="store">Whether <code>value</code> should be stored in the index /// </param> /// <param name="index">Whether the field should be indexed, and if so, if it should /// be tokenized before indexing /// </param> /// <param name="termVector">Whether term vector should be stored /// </param> /// <throws> NullPointerException if name or value is <code>null</code> </throws> /// <throws> IllegalArgumentException in any of the following situations: </throws> /// <summary> <ul> /// <li>the field is neither stored nor indexed</li> /// <li>the field is not indexed but termVector is <code>TermVector.YES</code></li> /// </ul> /// </summary> public Field(System.String name, bool internName, System.String value_Renamed, Store store, Index index, TermVector termVector) { if (name == null) { throw new System.NullReferenceException("name cannot be null"); } if (value_Renamed == null) { throw new System.NullReferenceException("value cannot be null"); } if (name.Length == 0 && value_Renamed.Length == 0) { throw new System.ArgumentException("name and value cannot both be empty"); } if (index == Index.NO && store == Store.NO) { throw new System.ArgumentException("it doesn't make sense to have a field that " + "is neither indexed nor stored"); } if (index == Index.NO && termVector != TermVector.NO) { throw new System.ArgumentException("cannot store term vector information " + "for a field that is not indexed"); } if (internName) { // field names are optionally interned name = StringHelper.Intern(name); } this.name = name; this.fieldsData = value_Renamed; if (store == Store.YES) { this.isStored = true; this.isCompressed = false; } else if (store == Store.COMPRESS) { this.isStored = true; this.isCompressed = true; } else if (store == Store.NO) { this.isStored = false; this.isCompressed = false; } else { throw new System.ArgumentException("unknown store parameter " + store); } if (index == Index.NO) { this.isIndexed = false; this.isTokenized = false; this.omitTermFreqAndPositions = false; this.omitNorms = true; } else if (index == Index.ANALYZED) { this.isIndexed = true; this.isTokenized = true; } else if (index == Index.NOT_ANALYZED) { this.isIndexed = true; this.isTokenized = false; } else if (index == Index.NOT_ANALYZED_NO_NORMS) { this.isIndexed = true; this.isTokenized = false; this.omitNorms = true; } else if (index == Index.ANALYZED_NO_NORMS) { this.isIndexed = true; this.isTokenized = true; this.omitNorms = true; } else { throw new System.ArgumentException("unknown index parameter " + index); } this.isBinary = false; SetStoreTermVector(termVector); }
protected internal AbstractField(System.String name, Field.Store store, Field.Index index, Field.TermVector termVector) { if (name == null) { throw new System.NullReferenceException("name cannot be null"); } this.name = StringHelper.Intern(name); // field names are interned if (store == Field.Store.YES) { this.isStored = true; this.isCompressed = false; } else if (store == Field.Store.COMPRESS) { this.isStored = true; this.isCompressed = true; } else if (store == Field.Store.NO) { this.isStored = false; this.isCompressed = false; } else { throw new System.ArgumentException("unknown store parameter " + store); } if (index == Field.Index.NO) { this.isIndexed = false; this.isTokenized = false; } else if (index == Field.Index.ANALYZED) { this.isIndexed = true; this.isTokenized = true; } else if (index == Field.Index.NOT_ANALYZED) { this.isIndexed = true; this.isTokenized = false; } else if (index == Field.Index.NOT_ANALYZED_NO_NORMS) { this.isIndexed = true; this.isTokenized = false; this.omitNorms = true; } else if (index == Field.Index.ANALYZED_NO_NORMS) { this.isIndexed = true; this.isTokenized = true; this.omitNorms = true; } else { throw new System.ArgumentException("unknown index parameter " + index); } this.isBinary = false; SetStoreTermVector(termVector); }
internal object custom; // which custom comparator or parser /// <summary>Creates one of these objects for a custom comparator/parser. </summary> internal Entry(string field, object custom) { this.field = StringHelper.Intern(field); this.custom = custom; }
/// <summary> Add a complete document specified by all its term vectors. If document has no /// term vectors, add value for tvx. /// /// </summary> /// <param name="vectors"> /// </param> /// <throws> IOException </throws> public void AddAllDocVectors(TermFreqVector[] vectors) { tvx.WriteLong(tvd.GetFilePointer()); tvx.WriteLong(tvf.GetFilePointer()); if (vectors != null) { int numFields = vectors.Length; tvd.WriteVInt(numFields); long[] fieldPointers = new long[numFields]; for (int i = 0; i < numFields; i++) { fieldPointers[i] = tvf.GetFilePointer(); int fieldNumber = fieldInfos.FieldNumber(vectors[i].GetField()); // 1st pass: write field numbers to tvd tvd.WriteVInt(fieldNumber); int numTerms = vectors[i].Size(); tvf.WriteVInt(numTerms); TermPositionVector tpVector; byte bits; bool storePositions; bool storeOffsets; if (vectors[i] is TermPositionVector) { // May have positions & offsets tpVector = (TermPositionVector)vectors[i]; storePositions = tpVector.Size() > 0 && tpVector.GetTermPositions(0) != null; storeOffsets = tpVector.Size() > 0 && tpVector.GetOffsets(0) != null; bits = (byte)((storePositions ? TermVectorsReader.STORE_POSITIONS_WITH_TERMVECTOR : (byte)0) + (storeOffsets ? TermVectorsReader.STORE_OFFSET_WITH_TERMVECTOR : (byte)0)); } else { tpVector = null; bits = 0; storePositions = false; storeOffsets = false; } tvf.WriteVInt(bits); string[] terms = vectors[i].GetTerms(); int[] freqs = vectors[i].GetTermFrequencies(); int utf8Upto = 0; utf8Results[1].length = 0; for (int j = 0; j < numTerms; j++) { UnicodeUtil.UTF16toUTF8(terms[j], 0, terms[j].Length, utf8Results[utf8Upto]); int start = StringHelper.bytesDifference( utf8Results[1 - utf8Upto].result, utf8Results[1 - utf8Upto].length, utf8Results[utf8Upto].result, utf8Results[utf8Upto].length); int length = utf8Results[utf8Upto].length - start; tvf.WriteVInt(start); // write shared prefix length tvf.WriteVInt(length); // write delta length tvf.WriteBytes(utf8Results[utf8Upto].result, start, length); // write delta bytes utf8Upto = 1 - utf8Upto; int termFreq = freqs[j]; tvf.WriteVInt(termFreq); if (storePositions) { int[] positions = tpVector.GetTermPositions(j); if (positions == null) { throw new System.SystemException("Trying to write positions that are null!"); } System.Diagnostics.Debug.Assert(positions.Length == termFreq); // use delta encoding for positions int lastPosition = 0; for (int k = 0; k < positions.Length; k++) { int position = positions[k]; tvf.WriteVInt(position - lastPosition); lastPosition = position; } } if (storeOffsets) { TermVectorOffsetInfo[] offsets = tpVector.GetOffsets(j); if (offsets == null) { throw new System.SystemException("Trying to write offsets that are null!"); } System.Diagnostics.Debug.Assert(offsets.Length == termFreq); // use delta encoding for offsets int lastEndOffset = 0; for (int k = 0; k < offsets.Length; k++) { int startOffset = offsets[k].GetStartOffset(); int endOffset = offsets[k].GetEndOffset(); tvf.WriteVInt(startOffset - lastEndOffset); tvf.WriteVInt(endOffset - startOffset); lastEndOffset = endOffset; } } } } // 2nd pass: write field pointers to tvd long lastFieldPointer = fieldPointers[0]; for (int i = 1; i < numFields; i++) { long fieldPointer = fieldPointers[i]; tvd.WriteVLong(fieldPointer - lastFieldPointer); lastFieldPointer = fieldPointer; } } else { tvd.WriteVInt(0); } }
/// <summary>Constructs a Term with the given field and text. /// <p/>Note that a null field or null text value results in undefined /// behavior for most Lucene APIs that accept a Term parameter. /// </summary> public Term(System.String fld, System.String txt) { field = StringHelper.Intern(fld); text = txt; }
/// <summary>Constructs a Term with the given field and text. /// <p/>Note that a null field or null text value results in undefined /// behavior for most Lucene APIs that accept a Term parameter. /// </summary> public Term(string fld, string txt) { field = StringHelper.Intern(fld); text = txt; }
private Term(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) { text = (string)info.GetValue("text", typeof(string)); field = StringHelper.Intern((string)info.GetValue("field", typeof(string))); }
protected internal override object CreateValue(IndexReader reader, Entry entryKey) { string field = StringHelper.Intern(entryKey.field); int[] retArray = new int[reader.MaxDoc]; string[] mterms = new string[reader.MaxDoc + 1]; TermDocs termDocs = reader.TermDocs(); TermEnum termEnum = reader.Terms(new Term(field)); int t = 0; // current term number // an entry for documents that have no terms in this field // should a document with no terms be at top or bottom? // this puts them at the top - if it is changed, FieldDocSortedHitQueue // needs to change as well. mterms[t++] = null; try { do { Term term = termEnum.Term; if (term == null || term.Field != field || t >= mterms.Length) { break; } // store term text mterms[t] = term.Text; termDocs.Seek(termEnum); while (termDocs.Next()) { retArray[termDocs.Doc] = t; } t++; }while (termEnum.Next()); } finally { termDocs.Close(); termEnum.Close(); } if (t == 0) { // if there are no terms, make the term array // have a single null entry mterms = new string[1]; } else if (t < mterms.Length) { // if there are less terms than documents, // trim off the dead array space string[] terms = new string[t]; Array.Copy(mterms, 0, terms, 0, t); mterms = terms; } StringIndex value_Renamed = new StringIndex(retArray, mterms); return(value_Renamed); }
internal void OnDeserialized(System.Runtime.Serialization.StreamingContext context) { field = StringHelper.Intern(field); }
private void WriteField() { // remember where this field is written currentField.tvfPointer = tvf.GetFilePointer(); //System.out.println("Field Pointer: " + currentField.tvfPointer); int size = terms.Count; tvf.WriteVInt(size); bool storePositions = currentField.storePositions; bool storeOffsets = currentField.storeOffsets; byte bits = (byte)(0x0); if (storePositions) { bits |= STORE_POSITIONS_WITH_TERMVECTOR; } if (storeOffsets) { bits |= STORE_OFFSET_WITH_TERMVECTOR; } tvf.WriteByte(bits); System.String lastTermText = ""; for (int i = 0; i < size; i++) { TVTerm term = (TVTerm)terms[i]; int start = StringHelper.StringDifference(lastTermText, term.termText); int length = term.termText.Length - start; tvf.WriteVInt(start); // write shared prefix length tvf.WriteVInt(length); // write delta length tvf.WriteChars(term.termText, start, length); // write delta chars tvf.WriteVInt(term.freq); lastTermText = term.termText; if (storePositions) { if (term.positions == null) { throw new System.SystemException("Trying to write positions that are null!"); } // use delta encoding for positions int position = 0; for (int j = 0; j < term.freq; j++) { tvf.WriteVInt(term.positions[j] - position); position = term.positions[j]; } } if (storeOffsets) { if (term.offsets == null) { throw new System.SystemException("Trying to write offsets that are null!"); } // use delta encoding for offsets int position = 0; for (int j = 0; j < term.freq; j++) { tvf.WriteVInt(term.offsets[j].GetStartOffset() - position); tvf.WriteVInt(term.offsets[j].GetEndOffset() - term.offsets[j].GetStartOffset()); //Save the diff between the two. position = term.offsets[j].GetEndOffset(); } } } }
internal Term(System.String fld, System.String txt, bool intern) { field = intern?StringHelper.Intern(fld):fld; // field names are interned text = txt; // unless already known to be }
public static void VerifyEquals(IndexReader r1, IndexReader r2, System.String idField) { Assert.AreEqual(r1.NumDocs(), r2.NumDocs()); bool hasDeletes = !(r1.MaxDoc() == r2.MaxDoc() && r1.NumDocs() == r1.MaxDoc()); int[] r2r1 = new int[r2.MaxDoc()]; // r2 id to r1 id mapping TermDocs termDocs1 = r1.TermDocs(); TermDocs termDocs2 = r2.TermDocs(); // create mapping from id2 space to id2 based on idField idField = StringHelper.Intern(idField); TermEnum termEnum = r1.Terms(new Term(idField, "")); do { Term term = termEnum.Term(); if (term == null || (System.Object)term.Field() != (System.Object)idField) { break; } termDocs1.Seek(termEnum); if (!termDocs1.Next()) { // This doc is deleted and wasn't replaced termDocs2.Seek(termEnum); Assert.IsFalse(termDocs2.Next()); continue; } int id1 = termDocs1.Doc(); Assert.IsFalse(termDocs1.Next()); termDocs2.Seek(termEnum); Assert.IsTrue(termDocs2.Next()); int id2 = termDocs2.Doc(); Assert.IsFalse(termDocs2.Next()); r2r1[id2] = id1; // verify stored fields are equivalent try { VerifyEquals(r1.Document(id1), r2.Document(id2)); } catch (System.Exception t) { System.Console.Out.WriteLine("FAILED id=" + term + " id1=" + id1 + " id2=" + id2 + " term=" + term); System.Console.Out.WriteLine(" d1=" + r1.Document(id1)); System.Console.Out.WriteLine(" d2=" + r2.Document(id2)); throw t; } try { // verify term vectors are equivalent VerifyEquals(r1.GetTermFreqVectors(id1), r2.GetTermFreqVectors(id2)); } catch (System.Exception e) { System.Console.Out.WriteLine("FAILED id=" + term + " id1=" + id1 + " id2=" + id2); TermFreqVector[] tv1 = r1.GetTermFreqVectors(id1); System.Console.Out.WriteLine(" d1=" + tv1); if (tv1 != null) { for (int i = 0; i < tv1.Length; i++) { System.Console.Out.WriteLine(" " + i + ": " + tv1[i]); } } TermFreqVector[] tv2 = r2.GetTermFreqVectors(id2); System.Console.Out.WriteLine(" d2=" + tv2); if (tv2 != null) { for (int i = 0; i < tv2.Length; i++) { System.Console.Out.WriteLine(" " + i + ": " + tv2[i]); } } throw e; } }while (termEnum.Next()); termEnum.Close(); // Verify postings TermEnum termEnum1 = r1.Terms(new Term("", "")); TermEnum termEnum2 = r2.Terms(new Term("", "")); // pack both doc and freq into single element for easy sorting long[] info1 = new long[r1.NumDocs()]; long[] info2 = new long[r2.NumDocs()]; for (; ;) { Term term1, term2; // iterate until we get some docs int len1; for (; ;) { len1 = 0; term1 = termEnum1.Term(); if (term1 == null) { break; } termDocs1.Seek(termEnum1); while (termDocs1.Next()) { int d1 = termDocs1.Doc(); int f1 = termDocs1.Freq(); info1[len1] = (((long)d1) << 32) | f1; len1++; } if (len1 > 0) { break; } if (!termEnum1.Next()) { break; } } // iterate until we get some docs int len2; for (; ;) { len2 = 0; term2 = termEnum2.Term(); if (term2 == null) { break; } termDocs2.Seek(termEnum2); while (termDocs2.Next()) { int d2 = termDocs2.Doc(); int f2 = termDocs2.Freq(); info2[len2] = (((long)r2r1[d2]) << 32) | f2; len2++; } if (len2 > 0) { break; } if (!termEnum2.Next()) { break; } } if (!hasDeletes) { Assert.AreEqual(termEnum1.DocFreq(), termEnum2.DocFreq()); } Assert.AreEqual(len1, len2); if (len1 == 0) { break; // no more terms } Assert.AreEqual(term1, term2); // sort info2 to get it into ascending docid System.Array.Sort(info2, 0, len2 - 0); // now compare for (int i = 0; i < len1; i++) { Assert.AreEqual(info1[i], info2[i]); } termEnum1.Next(); termEnum2.Next(); } }
protected internal override System.Object CreateValue(IndexReader reader, Entry entryKey) { System.String field = StringHelper.Intern((System.String)entryKey.field); int[] retArray = new int[reader.MaxDoc()]; System.String[] mterms = new System.String[reader.MaxDoc() + 1]; TermDocs termDocs = reader.TermDocs(); TermEnum termEnum = reader.Terms(new Term(field)); int t = 0; // current term number // an entry for documents that have no terms in this field // should a document with no terms be at top or bottom? // this puts them at the top - if it is changed, FieldDocSortedHitQueue // needs to change as well. mterms[t++] = null; try { do { Term term = termEnum.Term(); if (term == null || (System.Object)term.Field() != (System.Object)field) { break; } // store term text // we expect that there is at most one term per document if (t >= mterms.Length) { throw new System.SystemException("there are more terms than " + "documents in field \"" + field + "\", but it's impossible to sort on " + "tokenized fields"); } mterms[t] = term.Text(); termDocs.Seek(termEnum); while (termDocs.Next()) { retArray[termDocs.Doc()] = t; } t++; }while (termEnum.Next()); } finally { termDocs.Close(); termEnum.Close(); } if (t == 0) { // if there are no terms, make the term array // have a single null entry mterms = new System.String[1]; } else if (t < mterms.Length) { // if there are less terms than documents, // trim off the dead array space System.String[] terms = new System.String[t]; Array.Copy(mterms, 0, terms, 0, t); mterms = terms; } StringIndex value_Renamed = new StringIndex(retArray, mterms); return(value_Renamed); }
internal System.Object custom; // which custom comparator or parser /// <summary>Creates one of these objects for a custom comparator/parser. </summary> internal Entry(System.String field, System.Object custom) { this.field = StringHelper.Intern(field); this.custom = custom; }