public override DocsAndPositionsEnum DocsAndPositions(IBits liveDocs, DocsAndPositionsEnum reuse, DocsAndPositionsFlags flags) { if (positions == null && startOffsets == null) { return(null); } // TODO: slightly sheisty return((DocsAndPositionsEnum)Docs(liveDocs, reuse, (DocsFlags)flags)); }
public override DocsAndPositionsEnum DocsAndPositions(IBits liveDocs, DocsAndPositionsEnum reuse, DocsAndPositionsFlags flags) { if (!outerInstance.HasPositions) { return(null); } DecodeMetaData(); return(outerInstance.outerInstance.postingsReader.DocsAndPositions(outerInstance.fieldInfo, state, liveDocs, reuse, flags)); }
public override DocsAndPositionsEnum DocsAndPositions(IBits liveDocs, DocsAndPositionsEnum reuse, DocsAndPositionsFlags flags) { DocsAndPositionsEnum inReuse; SortingDocsAndPositionsEnum wrapReuse; if (reuse != null && reuse is SortingDocsAndPositionsEnum) { // if we're asked to reuse the given DocsEnum and it is Sorting, return // the wrapped one, since some Codecs expect it. wrapReuse = (SortingDocsAndPositionsEnum)reuse; inReuse = wrapReuse.Wrapped; } else { wrapReuse = null; inReuse = reuse; } DocsAndPositionsEnum inDocsAndPositions = m_input.DocsAndPositions(NewToOld(liveDocs), inReuse, flags); if (inDocsAndPositions == null) { return(null); } // we ignore the fact that offsets may be stored but not asked for, // since this code is expected to be used during addIndexes which will // ask for everything. if that assumption changes in the future, we can // factor in whether 'flags' says offsets are not required. bool storeOffsets = indexOptions.CompareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS) >= 0; return(new SortingDocsAndPositionsEnum(docMap.Count, wrapReuse, inDocsAndPositions, docMap, storeOffsets)); }
public override DocsAndPositionsEnum DocsAndPositions(IBits liveDocs, DocsAndPositionsEnum reuse, DocsAndPositionsFlags flags) { return(new TestPositions(base.DocsAndPositions(liveDocs, reuse == null ? null : ((FilterDocsAndPositionsEnum)reuse).m_input, flags))); }
public override DocsAndPositionsEnum DocsAndPositions(IBits liveDocs, DocsAndPositionsEnum reuse, DocsAndPositionsFlags flags) { throw IllegalStateException.Create("this method should never be called"); }
/// <summary> /// Returns <see cref="DocsAndPositionsEnum"/> for the specified /// field & term, with control over whether offsets and payloads are /// required. Some codecs may be able to optimize /// their implementation when offsets and/or payloads are not /// required. This will return <c>null</c> if the field or term does not /// exist or positions were not indexed. See /// <see cref="TermsEnum.DocsAndPositions(IBits, DocsAndPositionsEnum, DocsAndPositionsFlags)"/>. /// </summary> public static DocsAndPositionsEnum GetTermPositionsEnum(IndexReader r, IBits liveDocs, string field, BytesRef term, DocsAndPositionsFlags flags) { Debug.Assert(field != null); Debug.Assert(term != null); Terms terms = GetTerms(r, field); if (terms != null) { TermsEnum termsEnum = terms.GetIterator(null); if (termsEnum.SeekExact(term)) { return(termsEnum.DocsAndPositions(liveDocs, null, flags)); } } return(null); }
public override DocsAndPositionsEnum DocsAndPositions(IBits liveDocs, DocsAndPositionsEnum reuse, DocsAndPositionsFlags flags) { if (!storePositions && !storeOffsets) { return(null); } TVDocsAndPositionsEnum docsAndPositionsEnum; if (reuse != null && reuse is TVDocsAndPositionsEnum) { docsAndPositionsEnum = (TVDocsAndPositionsEnum)reuse; } else { docsAndPositionsEnum = new TVDocsAndPositionsEnum(); } docsAndPositionsEnum.Reset(liveDocs, positions, startOffsets, endOffsets, payloadOffsets, payloadData); return(docsAndPositionsEnum); }
/// <summary> /// Must fully consume state, since after this call that /// <see cref="TermState"/> may be reused. /// </summary> public abstract DocsAndPositionsEnum DocsAndPositions(FieldInfo fieldInfo, BlockTermState state, IBits skipDocs, DocsAndPositionsEnum reuse, DocsAndPositionsFlags flags);
public override DocsAndPositionsEnum DocsAndPositions(IBits liveDocs, DocsAndPositionsEnum reuse, DocsAndPositionsFlags flags) { // Can only reuse if incoming enum is also a MultiDocsAndPositionsEnum // ... and was previously created w/ this MultiTermsEnum: if (reuse is null || !(reuse is MultiDocsAndPositionsEnum docsAndPositionsEnum) || !docsAndPositionsEnum.CanReuse(this)) docsAndPositionsEnum = new MultiDocsAndPositionsEnum(this, subs.Length); int upto = 0; for (int i = 0; i < numTop; i++) { TermsEnumWithSlice entry = top[i]; IBits b; if (liveDocs is MultiBits multiLiveDocs) { // Optimize for common case: requested skip docs is a // congruent sub-slice of MultiBits: in this case, we // just pull the liveDocs from the sub reader, rather // than making the inefficient // Slice(Multi(sub-readers)): MultiBits.SubResult sub = multiLiveDocs.GetMatchingSub(top[i].SubSlice); if (sub.Matches) { b = sub.Result; } else { // custom case: requested skip docs is foreign: // must slice it on every access (very // inefficient) b = new BitsSlice(liveDocs, top[i].SubSlice); } } else if (liveDocs != null) { b = new BitsSlice(liveDocs, top[i].SubSlice); } else { // no deletions b = null; } if (Debugging.AssertsEnabled) Debugging.Assert(entry.Index < docsAndPositionsEnum.subDocsAndPositionsEnum.Length, "{0} vs {1}; {2}", entry.Index, docsAndPositionsEnum.subDocsAndPositionsEnum.Length, subs.Length); DocsAndPositionsEnum subPostings = entry.Terms.DocsAndPositions(b, docsAndPositionsEnum.subDocsAndPositionsEnum[entry.Index], flags); if (subPostings != null) { docsAndPositionsEnum.subDocsAndPositionsEnum[entry.Index] = subPostings; subDocsAndPositions[upto].DocsAndPositionsEnum = subPostings; subDocsAndPositions[upto].Slice = entry.SubSlice; upto++; } else { if (entry.Terms.Docs(b, null, DocsFlags.NONE) != null) { // At least one of our subs does not store // offsets or positions -- we can't correctly // produce a MultiDocsAndPositions enum return null; } } } if (upto == 0) { return null; } else { return docsAndPositionsEnum.Reset(subDocsAndPositions, upto); } }
public override DocsAndPositionsEnum DocsAndPositions(IBits liveDocs, DocsAndPositionsEnum reuse, DocsAndPositionsFlags flags) { if (reuse is null || !(reuse is MemoryDocsAndPositionsEnum toReuse)) { toReuse = new MemoryDocsAndPositionsEnum(outerInstance); } int ord = info.sortedTerms[termUpto]; return(toReuse.Reset(liveDocs, info.sliceArray.start[ord], info.sliceArray.end[ord], info.sliceArray.freq[ord])); }
public override DocsAndPositionsEnum DocsAndPositions(IBits liveDocs, DocsAndPositionsEnum reuse, DocsAndPositionsFlags flags) { var postings = _current.Value; if (postings.positions == null && postings.startOffsets == null) { return(null); } // TODO: reuse var e = new SimpleTVDocsAndPositionsEnum(); e.Reset(liveDocs, postings.positions, postings.startOffsets, postings.endOffsets, postings.payloads); return(e); }
public override DocsAndPositionsEnum DocsAndPositions(IBits liveDocs, DocsAndPositionsEnum reuse, DocsAndPositionsFlags flags) { throw new InvalidOperationException("this method should never be called"); }
public override DocsAndPositionsEnum DocsAndPositions(IBits bits, DocsAndPositionsEnum reuse, DocsAndPositionsFlags flags) { return(tenum.DocsAndPositions(bits, reuse, flags)); }
public override DocsAndPositionsEnum DocsAndPositions(IBits liveDocs, DocsAndPositionsEnum reuse, DocsAndPositionsFlags flags) { // LUCENENET specific - to avoid boxing, changed from CompareTo() to IndexOptionsComparer.Compare() if (IndexOptionsComparer.Default.Compare(_indexOptions, IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) < 0) { // Positions were not indexed return(null); } if (reuse is null || !(reuse is SimpleTextDocsAndPositionsEnum docsAndPositionsEnum) || !docsAndPositionsEnum.CanReuse(_outerInstance._input)) { docsAndPositionsEnum = new SimpleTextDocsAndPositionsEnum(_outerInstance); } return(docsAndPositionsEnum.Reset(_docsStart, liveDocs, _indexOptions, _docFreq)); }
public override DocsAndPositionsEnum DocsAndPositions(IBits liveDocs, DocsAndPositionsEnum reuse, DocsAndPositionsFlags flags) { // LUCENENET specific - to avoid boxing, changed from CompareTo() to IndexOptionsComparer.Compare() bool hasOffsets = IndexOptionsComparer.Default.Compare(field.IndexOptions, IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS) >= 0; if (IndexOptionsComparer.Default.Compare(field.IndexOptions, IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) < 0) { return(null); } DecodeMetaData(); if (reuse is null || !(reuse is FSTDocsAndPositionsEnum docsAndPositionsEnum) || !docsAndPositionsEnum.CanReuse(field.HasPayloads, hasOffsets)) { docsAndPositionsEnum = new FSTDocsAndPositionsEnum(field.HasPayloads, hasOffsets); } //System.out.println("D&P reset this=" + this); return(docsAndPositionsEnum.Reset(postingsSpare, liveDocs, docFreq)); }
public override DocsAndPositionsEnum DocsAndPositions(IBits liveDocs, DocsAndPositionsEnum reuse, DocsAndPositionsFlags flags) { if (Debugging.AssertsEnabled) { Debugging.Assert(state == State.POSITIONED, "DocsAndPositions(...) called on unpositioned TermsEnum"); } // TODO: should we give this thing a random to be super-evil, // and randomly *not* unwrap? if (reuse is AssertingDocsAndPositionsEnum) { reuse = ((AssertingDocsAndPositionsEnum)reuse).m_input; } DocsAndPositionsEnum docs = base.DocsAndPositions(liveDocs, reuse, flags); return(docs == null ? null : new AssertingDocsAndPositionsEnum(docs)); }
public override DocsAndPositionsEnum DocsAndPositions(IBits liveDocs, DocsAndPositionsEnum reuse, DocsAndPositionsFlags flags) { return(actualEnum.DocsAndPositions(liveDocs, reuse, flags)); }
public override DocsAndPositionsEnum DocsAndPositions(IBits liveDocs, DocsAndPositionsEnum reuse, DocsAndPositionsFlags flags) { return(new RAMDocsAndPositionsEnum(ramField.termToDocs[current], liveDocs)); }
public override DocsAndPositionsEnum DocsAndPositions(IBits liveDocs, DocsAndPositionsEnum reuse, DocsAndPositionsFlags flags) { return(@delegate.DocsAndPositions(liveDocs, reuse, flags)); }
public override DocsAndPositionsEnum DocsAndPositions(IBits liveDocs, DocsAndPositionsEnum reuse, DocsAndPositionsFlags flags) { if (!storePositions && !storeOffsets) { return(null); } if (reuse is null || !(reuse is TVDocsAndPositionsEnum docsAndPositionsEnum)) { docsAndPositionsEnum = new TVDocsAndPositionsEnum(); } docsAndPositionsEnum.Reset(liveDocs, termAndPostings[currentTerm]); return(docsAndPositionsEnum); }
public override DocsAndPositionsEnum DocsAndPositions(IBits liveDocs, DocsAndPositionsEnum reuse, DocsAndPositionsFlags flags) { if (_indexOptions.CompareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) < 0) { // Positions were not indexed return(null); } SimpleTextDocsAndPositionsEnum docsAndPositionsEnum; if (reuse != null && reuse is SimpleTextDocsAndPositionsEnum && ((SimpleTextDocsAndPositionsEnum)reuse).CanReuse(_outerInstance._input)) { docsAndPositionsEnum = (SimpleTextDocsAndPositionsEnum)reuse; } else { docsAndPositionsEnum = new SimpleTextDocsAndPositionsEnum(_outerInstance); } return(docsAndPositionsEnum.Reset(_docsStart, liveDocs, _indexOptions, _docFreq)); }
public override DocsAndPositionsEnum DocsAndPositions(FieldInfo fieldInfo, BlockTermState termState, IBits liveDocs, DocsAndPositionsEnum reuse, DocsAndPositionsFlags flags) { Debug.Assert(fieldInfo.IndexOptions == IndexOptions.DOCS_AND_FREQS_AND_POSITIONS); SepTermState termState_ = (SepTermState)termState; SepDocsAndPositionsEnum postingsEnum; if (reuse == null || !(reuse is SepDocsAndPositionsEnum)) { postingsEnum = new SepDocsAndPositionsEnum(this); } else { postingsEnum = (SepDocsAndPositionsEnum)reuse; if (postingsEnum.startDocIn != docIn) { // If you are using ParellelReader, and pass in a // reused DocsAndPositionsEnum, it could have come // from another reader also using sep codec postingsEnum = new SepDocsAndPositionsEnum(this); } } return(postingsEnum.Init(fieldInfo, termState_, liveDocs)); }
/// <summary> /// Get <see cref="DocsAndPositionsEnum"/> for the current term, /// with control over whether offsets and payloads are /// required. Some codecs may be able to optimize their /// implementation when offsets and/or payloads are not required. /// Do not call this when the enum is unpositioned. This /// will return <c>null</c> if positions were not indexed. /// </summary> /// <param name="liveDocs"> Unset bits are documents that should not /// be returned </param> /// <param name="reuse"> Pass a prior DocsAndPositionsEnum for possible reuse </param> /// <param name="flags"> Specifies which optional per-position values you /// require; see <see cref="DocsAndPositionsFlags"/>. </param> public abstract DocsAndPositionsEnum DocsAndPositions(IBits liveDocs, DocsAndPositionsEnum reuse, DocsAndPositionsFlags flags);
public override DocsAndPositionsEnum DocsAndPositions(IBits liveDocs, DocsAndPositionsEnum reuse, DocsAndPositionsFlags flags) { throw UnsupportedOperationException.Create(); }
public override DocsAndPositionsEnum DocsAndPositions(IBits liveDocs, DocsAndPositionsEnum reuse, DocsAndPositionsFlags flags) { PreDocsAndPositionsEnum docsPosEnum; if (fieldInfo.IndexOptions != IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) { return(null); } else if (reuse == null || !(reuse is PreDocsAndPositionsEnum)) { docsPosEnum = new PreDocsAndPositionsEnum(outerInstance); } else { docsPosEnum = (PreDocsAndPositionsEnum)reuse; if (docsPosEnum.FreqStream != outerInstance.FreqStream) { docsPosEnum = new PreDocsAndPositionsEnum(outerInstance); } } return(docsPosEnum.Reset(termEnum, liveDocs)); }
public override DocsAndPositionsEnum DocsAndPositions(FieldInfo fieldInfo, BlockTermState termState, IBits liveDocs, DocsAndPositionsEnum reuse, DocsAndPositionsFlags flags) { // LUCENENET specific - to avoid boxing, changed from CompareTo() to IndexOptionsComparer.Compare() bool hasOffsets = IndexOptionsComparer.Default.Compare(fieldInfo.IndexOptions, IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS) >= 0; // TODO: can we optimize if FLAG_PAYLOADS / FLAG_OFFSETS // isn't passed? // TODO: refactor if (fieldInfo.HasPayloads || hasOffsets) { // If you are using ParellelReader, and pass in a // reused DocsEnum, it could have come from another // reader also using standard codec if (reuse is null || !(reuse is SegmentFullPositionsEnum docsEnum) || docsEnum.startFreqIn != freqIn) { docsEnum = new SegmentFullPositionsEnum(this, freqIn, proxIn); } return(docsEnum.Reset(fieldInfo, (StandardTermState)termState, liveDocs)); } else { // If you are using ParellelReader, and pass in a // reused DocsEnum, it could have come from another // reader also using standard codec if (reuse is null || !(reuse is SegmentDocsAndPositionsEnum docsEnum) || docsEnum.startFreqIn != freqIn) { docsEnum = new SegmentDocsAndPositionsEnum(this, freqIn, proxIn); } return(docsEnum.Reset(fieldInfo, (StandardTermState)termState, liveDocs)); } }
public override DocsAndPositionsEnum DocsAndPositions(IBits liveDocs, DocsAndPositionsEnum reuse, DocsAndPositionsFlags flags) { throw new NotSupportedException(); }
public override DocsAndPositionsEnum DocsAndPositions(IBits liveDocs, DocsAndPositionsEnum reuse, DocsAndPositionsFlags flags) { bool hasOffsets = field.IndexOptions.CompareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS) >= 0; if (field.IndexOptions.CompareTo(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) < 0) { return(null); } DecodeMetaData(); FSTDocsAndPositionsEnum docsAndPositionsEnum; if (reuse == null || !(reuse is FSTDocsAndPositionsEnum)) { docsAndPositionsEnum = new FSTDocsAndPositionsEnum(field.HasPayloads, hasOffsets); } else { docsAndPositionsEnum = (FSTDocsAndPositionsEnum)reuse; if (!docsAndPositionsEnum.CanReuse(field.HasPayloads, hasOffsets)) { docsAndPositionsEnum = new FSTDocsAndPositionsEnum(field.HasPayloads, hasOffsets); } } //System.out.println("D&P reset this=" + this); return(docsAndPositionsEnum.Reset(postingsSpare, liveDocs, docFreq_Renamed)); }