public virtual void Reset(IBits liveDocs, TermAndPostings termAndPostings) { this.liveDocs = liveDocs; this.freq = termAndPostings.Freq; this.doc = -1; didNext = false; }
public override DocIdSet GetDocIdSet(AtomicReaderContext context, IBits acceptDocs) { SortedDocValues fcsi = FieldCache.GetTermsIndex((context.AtomicReader), field); FixedBitSet bits = new FixedBitSet(fcsi.ValueCount); for (int i = 0; i < terms.Length; i++) { int ord = fcsi.LookupTerm(terms[i]); if (ord >= 0) { bits.Set(ord); } } return(new FieldCacheDocIdSet(context.Reader.MaxDoc, acceptDocs, (doc) => { int ord = fcsi.GetOrd(doc); if (ord == -1) { // missing return false; } else { return bits.Get(ord); } })); }
public DocIdSetAnonymousInnerClassHelper(QueryWrapperFilter outerInstance, IBits acceptDocs, AtomicReaderContext privateContext, Lucene.Net.Search.Weight weight) { this.outerInstance = outerInstance; this.acceptDocs = acceptDocs; this.privateContext = privateContext; this.weight = weight; }
public override DocIdSet GetDocIdSet(AtomicReaderContext context, IBits acceptDocs) { // get a private context that is used to rewrite, createWeight and score eventually AtomicReaderContext privateContext = context.AtomicReader.AtomicContext; Weight weight = (new IndexSearcher(privateContext)).CreateNormalizedWeight(query); return(new DocIdSetAnonymousInnerClassHelper(this, acceptDocs, privateContext, weight)); }
public virtual void Reset(IBits liveDocs, TermAndPostings termAndPostings) { this.liveDocs = liveDocs; this.positions = termAndPostings.Positions; this.startOffsets = termAndPostings.StartOffsets; this.endOffsets = termAndPostings.EndOffsets; this.doc = -1; didNext = false; nextPos = 0; }
public override DocsEnum Docs(IBits liveDocs, DocsEnum reuse, DocsFlags flags) // ignored { if (reuse is null || !(reuse is TVDocsEnum docsEnum)) { docsEnum = new TVDocsEnum(); } docsEnum.Reset(liveDocs, termAndPostings[currentTerm]); return(docsEnum); }
public override DocsEnum Docs(IBits liveDocs, DocsEnum reuse, DocsFlags flags) // ignored { TVDocsEnum docsEnum; if (reuse != null && reuse is TVDocsEnum) { docsEnum = (TVDocsEnum)reuse; } else { docsEnum = new TVDocsEnum(); } docsEnum.Reset(liveDocs, termAndPostings[currentTerm]); return(docsEnum); }
public override DocIdSet GetDocIdSet(AtomicReaderContext context, IBits acceptDocs) { SortedDocValues fcsi = FieldCache.GetTermsIndex((context.AtomicReader), field); FixedBitSet bits = new FixedBitSet(fcsi.ValueCount); for (int i = 0; i < terms.Length; i++) { int ord = fcsi.LookupTerm(terms[i]); if (ord >= 0) { bits.Set(ord); } } return(new FieldCacheDocIdSetAnonymousInnerClassHelper(this, context.Reader.MaxDoc, acceptDocs, fcsi, bits)); }
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 FieldCacheDocIdSetAnonymousInnerClassHelper(FieldCacheTermsFilter outerInstance, int maxDoc, IBits acceptDocs, SortedDocValues fcsi, FixedBitSet bits) : base(maxDoc, acceptDocs) { this.outerInstance = outerInstance; this.fcsi = fcsi; this.bits = bits; }
public BitsAnonymousInnerClassHelper(FilteredDocIdSet outerInstance, IBits bits) { this.outerInstance = outerInstance; this.bits = bits; }
public override Scorer GetScorer(AtomicReaderContext context, IBits acceptDocs) { return(new PayloadTermSpanScorer(this, (TermSpans)m_query.GetSpans(context, acceptDocs, m_termContexts), this, m_similarity.GetSimScorer(m_stats, context))); }
public FieldCacheDocIdSet(int maxDoc, IBits acceptDocs) { this.m_maxDoc = maxDoc; this.m_acceptDocs = acceptDocs; }
/// <summary> /// Optional method, to return a <see cref="BulkScorer"/> to /// score the query and send hits to a <see cref="ICollector"/>. /// Only queries that have a different top-level approach /// need to override this; the default implementation /// pulls a normal <see cref="Scorer"/> and iterates and /// collects the resulting hits. /// </summary> /// <param name="context"> /// The <see cref="AtomicReaderContext"/> for which to return the <see cref="Scorer"/>. </param> /// <param name="scoreDocsInOrder"> /// Specifies whether in-order scoring of documents is required. Note /// that if set to <c>false</c> (i.e., out-of-order scoring is required), /// this method can return whatever scoring mode it supports, as every /// in-order scorer is also an out-of-order one. However, an /// out-of-order scorer may not support <see cref="DocIdSetIterator.NextDoc()"/> /// and/or <see cref="DocIdSetIterator.Advance(int)"/>, therefore it is recommended to /// request an in-order scorer if use of these /// methods is required. </param> /// <param name="acceptDocs"> /// <see cref="IBits"/> that represent the allowable docs to match (typically deleted docs /// but possibly filtering other documents) /// </param> /// <returns> A <see cref="BulkScorer"/> which scores documents and /// passes them to a collector. </returns> /// <exception cref="System.IO.IOException"> if there is a low-level I/O error </exception> public virtual BulkScorer GetBulkScorer(AtomicReaderContext context, bool scoreDocsInOrder, IBits acceptDocs) { Scorer scorer = GetScorer(context, acceptDocs); if (scorer == null) { // No docs match return(null); } // this impl always scores docs in order, so we can // ignore scoreDocsInOrder: return(new DefaultBulkScorer(scorer)); }
/// <summary> /// Returns a <see cref="Scorer"/> which scores documents in/out-of order according /// to <c>scoreDocsInOrder</c>. /// <para/> /// <b>NOTE:</b> even if <c>scoreDocsInOrder</c> is <c>false</c>, it is /// recommended to check whether the returned <see cref="Scorer"/> indeed scores /// documents out of order (i.e., call <see cref="ScoresDocsOutOfOrder"/>), as /// some <see cref="Scorer"/> implementations will always return documents /// in-order. /// <para/> /// <b>NOTE:</b> <c>null</c> can be returned if no documents will be scored by this /// query. /// </summary> /// <param name="context"> /// The <see cref="AtomicReaderContext"/> for which to return the <see cref="Scorer"/>. </param> /// <param name="acceptDocs"> /// <see cref="IBits"/> that represent the allowable docs to match (typically deleted docs /// but possibly filtering other documents) /// </param> /// <returns> A <see cref="Scorer"/> which scores documents in/out-of order. </returns> /// <exception cref="System.IO.IOException"> if there is a low-level I/O error </exception> public abstract Scorer GetScorer(AtomicReaderContext context, IBits acceptDocs);