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)
{
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 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)
{
// 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 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 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 DocIdSet GetDocIdSet(AtomicReaderContext context, IBits acceptDocs)
{
FixedBitSet bits = new FixedBitSet(context.Reader.MaxDoc);
bits.Set(Doc);
if (acceptDocs != null && !acceptDocs.Get(Doc))
{
bits.Clear(Doc);
}
return(bits);
}
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 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;
}
public BitsAnonymousClass(FilteredDocIdSet outerInstance, IBits bits)
{
this.outerInstance = outerInstance;
this.bits = bits;
}
public override DocIdSet GetDocIdSet(AtomicReaderContext context, IBits acceptDocs)
{
wasCalled = true;
return(new FixedBitSet(context.Reader.MaxDoc));
}
public FieldCacheDocIdSetAnonymousInnerClassHelper(FieldCacheTermsFilter outerInstance, int maxDoc, IBits acceptDocs, SortedDocValues fcsi, FixedBitSet bits)
: base(maxDoc, acceptDocs)
{
this.outerInstance = outerInstance;
this.fcsi = fcsi;
this.bits = bits;
}
/// <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);
/// <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));
}
