/// <summary>Advance to non excluded doc.
/// <br/>On entry:
/// <list type="bullet">
/// <item>reqScorer != null, </item>
/// <item>exclScorer != null, </item>
/// <item>reqScorer was advanced once via next() or skipTo()
/// and reqScorer.doc() may still be excluded.</item>
/// </list>
/// Advances reqScorer a non excluded required doc, if any.
/// </summary>
/// <returns> true iff there is a non excluded required doc.
/// </returns>
private int ToNonExcluded()
{
int exclDoc = exclDisi.DocID();
int reqDoc = reqScorer.DocID(); // may be excluded
do
{
if (reqDoc < exclDoc)
{
return(reqDoc); // reqScorer advanced to before exclScorer, ie. not excluded
}
else if (reqDoc > exclDoc)
{
exclDoc = exclDisi.Advance(reqDoc);
if (exclDoc == NO_MORE_DOCS)
{
exclDisi = null; // exhausted, no more exclusions
return(reqDoc);
}
if (exclDoc > reqDoc)
{
return(reqDoc); // not excluded
}
}
}while ((reqDoc = reqScorer.NextDoc()) != NO_MORE_DOCS);
reqScorer = null; // exhausted, nothing left
return(NO_MORE_DOCS);
}
/// <summary>
/// Does in-place AND of the bits provided by the
/// iterator.
/// </summary>
public void And(DocIdSetIterator iter)
{
if (iter.DocID == -1 && iter is OpenBitSetIterator obs)
{
And(obs.arr, obs.words);
// advance after last doc that would be accepted if standard
// iteration is used (to exhaust it):
obs.Advance(numBits);
}
else if (iter.DocID == -1 && iter is FixedBitSetIterator fbs)
{
And(fbs.bits, fbs.numWords);
// advance after last doc that would be accepted if standard
// iteration is used (to exhaust it):
fbs.Advance(numBits);
}
else
{
if (numBits == 0)
{
return;
}
int disiDoc, bitSetDoc = NextSetBit(0);
while (bitSetDoc != -1 && (disiDoc = iter.Advance(bitSetDoc)) < numBits)
{
Clear(bitSetDoc, disiDoc);
disiDoc++;
bitSetDoc = (disiDoc < numBits) ? NextSetBit(disiDoc) : -1;
}
if (bitSetDoc != -1)
{
Clear(bitSetDoc, numBits);
}
}
}
internal virtual void DoIterate2(BitSet a, FixedBitSet b)
{
int aa = -1, bb = -1;
DocIdSetIterator iterator = b.GetIterator();
do
{
aa = a.NextSetBit(aa + 1);
bb = Random.NextBoolean() ? iterator.NextDoc() : iterator.Advance(bb + 1);
Assert.AreEqual(aa == -1 ? DocIdSetIterator.NO_MORE_DOCS : aa, bb);
} while (aa >= 0);
}
public override int Advance(int target)
{
if (lastReturn == DocIdSetIterator.NO_MORE_DOCS)
{
return(DocIdSetIterator.NO_MORE_DOCS);
}
if (target <= lastReturn)
{
target = lastReturn + 1;
}
var max = this.getMax();
if (target >= max)
{
return(lastReturn = DocIdSetIterator.NO_MORE_DOCS);
}
if (it1 != null && innerDocid < target)
{
if ((innerDocid = it1.Advance(target)) == DocIdSetIterator.NO_MORE_DOCS)
{
it1 = null;
}
}
while (it1 != null && innerDocid == target)
{
target++;
if (target >= max)
{
return(lastReturn = DocIdSetIterator.NO_MORE_DOCS);
}
if ((innerDocid = it1.Advance(target)) == DocIdSetIterator.NO_MORE_DOCS)
{
it1 = null;
}
}
return(lastReturn = target);
}
public override int Advance(int target)
{
if (lastReturn == DocIdSetIterator.NO_MORE_DOCS)
{
return(DocIdSetIterator.NO_MORE_DOCS);
}
DocIdSetIterator dcit = iterators[0];
target = dcit.Advance(target);
int size = iterators.Length;
int skip = 0;
int i = 1;
while (i < size)
{
if (i != skip)
{
dcit = iterators[i];
int docid = dcit.Advance(target);
if (docid > target)
{
target = docid;
if (i != 0)
{
skip = i;
i = 0;
continue;
}
else
{
skip = 0;
}
}
}
i++;
}
return(lastReturn = target);
}
/// <summary>
/// Perform an inplace AND with the doc ids from a given DocIdSetIterator,
/// leaving only the bits set for which the doc ids are in common.
/// These doc ids should be smaller than the maximum size passed to the
/// constructor.
/// </summary>
public virtual void InPlaceAnd(DocIdSetIterator disi)
{
int bitSetDoc = NextSetBit(0);
int disiDoc;
while (bitSetDoc != -1 && (disiDoc = disi.Advance(bitSetDoc)) != DocIdSetIterator.NO_MORE_DOCS)
{
Clear(bitSetDoc, disiDoc);
bitSetDoc = NextSetBit(disiDoc + 1);
}
if (bitSetDoc != -1)
{
Clear(bitSetDoc, Length); // LUCENENET specific - using Length in place of Size (since they are the same)
}
}
/// <summary> Perform an inplace AND with the doc ids from a given DocIdSetIterator,
/// leaving only the bits set for which the doc ids are in common.
/// These doc ids should be smaller than the maximum size passed to the
/// constructor.
/// </summary>
public virtual void InPlaceAnd(DocIdSetIterator disi)
{
int bitSetDoc = NextSetBit(0);
int disiDoc;
while (bitSetDoc != -1 && (disiDoc = disi.Advance(bitSetDoc)) != DocIdSetIterator.NO_MORE_DOCS)
{
Clear(bitSetDoc, disiDoc);
bitSetDoc = NextSetBit(disiDoc + 1);
}
if (bitSetDoc != -1)
{
Clear(bitSetDoc, Size());
}
}
public sealed override int Advance(int target)
{
int docid = _innerIter.Advance(target);
while (docid != DocIdSetIterator.NO_MORE_DOCS)
{
if (Match(docid))
{
_currentDoc = docid;
return(docid);
}
else
{
docid = _innerIter.NextDoc();
}
}
return(DocIdSetIterator.NO_MORE_DOCS);
}
public override int Advance(int target)
{
if (m_curDoc == DocIdSetIterator.NO_MORE_DOCS)
{
return(DocIdSetIterator.NO_MORE_DOCS);
}
if (target <= m_curDoc)
{
target = m_curDoc + 1;
}
Item top = m_heap[0];
while (true)
{
DocIdSetIterator topIter = top.Iter;
int docid;
if ((docid = topIter.Advance(target)) != DocIdSetIterator.NO_MORE_DOCS)
{
top.Doc = docid;
HeapAdjust();
}
else
{
HeapRemoveRoot();
if (m_size == 0)
{
return(m_curDoc = DocIdSetIterator.NO_MORE_DOCS);
}
}
top = m_heap[0];
int topDoc = top.Doc;
if (topDoc >= target)
{
return(m_curDoc = topDoc);
}
}
}
public override int Advance(int target)
{
Doc = _innerIter.Advance(target);
if (Doc != NO_MORE_DOCS)
{
if (Match(Doc))
{
return(Doc);
}
else
{
while ((Doc = _innerIter.NextDoc()) != NO_MORE_DOCS)
{
if (Match(Doc))
{
return(Doc);
}
}
return(Doc);
}
}
return(Doc);
}
/// <summary>
/// Assert that the content of the <see cref="DocIdSet"/> is the same as the content of the <see cref="BitSet"/>.
/// </summary>
#pragma warning disable xUnit1013
public virtual void AssertEquals(int numBits, BitSet ds1, T ds2)
#pragma warning restore xUnit1013
{
// nextDoc
DocIdSetIterator it2 = ds2.GetIterator();
if (it2 == null)
{
Assert.AreEqual(-1, ds1.NextSetBit(0));
}
else
{
Assert.AreEqual(-1, it2.DocID);
for (int doc = ds1.NextSetBit(0); doc != -1; doc = ds1.NextSetBit(doc + 1))
{
Assert.AreEqual(doc, it2.NextDoc());
Assert.AreEqual(doc, it2.DocID);
}
Assert.AreEqual(DocIdSetIterator.NO_MORE_DOCS, it2.NextDoc());
Assert.AreEqual(DocIdSetIterator.NO_MORE_DOCS, it2.DocID);
}
// nextDoc / advance
it2 = ds2.GetIterator();
if (it2 == null)
{
Assert.AreEqual(-1, ds1.NextSetBit(0));
}
else
{
for (int doc = -1; doc != DocIdSetIterator.NO_MORE_DOCS;)
{
if (Random.NextBoolean())
{
doc = ds1.NextSetBit(doc + 1);
if (doc == -1)
{
doc = DocIdSetIterator.NO_MORE_DOCS;
}
Assert.AreEqual(doc, it2.NextDoc());
Assert.AreEqual(doc, it2.DocID);
}
else
{
int target = doc + 1 + Random.Next(Random.NextBoolean() ? 64 : Math.Max(numBits / 8, 1));
doc = ds1.NextSetBit(target);
if (doc == -1)
{
doc = DocIdSetIterator.NO_MORE_DOCS;
}
Assert.AreEqual(doc, it2.Advance(target));
Assert.AreEqual(doc, it2.DocID);
}
}
}
// bits()
IBits bits = ds2.Bits;
if (bits != null)
{
// test consistency between bits and iterator
it2 = ds2.GetIterator();
for (int previousDoc = -1, doc = it2.NextDoc(); ; previousDoc = doc, doc = it2.NextDoc())
{
int max = doc == DocIdSetIterator.NO_MORE_DOCS ? bits.Length : doc;
for (int i = previousDoc + 1; i < max; ++i)
{
Assert.AreEqual(false, bits.Get(i));
}
if (doc == DocIdSetIterator.NO_MORE_DOCS)
{
break;
}
Assert.AreEqual(true, bits.Get(doc));
}
}
}
public override int Advance(int target)
{
return(m_docSetIter.Advance(target));
}
public override int Advance(int target)
{
return(currentDoc = matchingDocsIterator.Advance(target));
}
/// <summary>
/// Used when base query is highly constraining vs the
/// drilldowns, or when the docs must be scored at once
/// (i.e., like <see cref="Search.BooleanScorer2"/>, not <see cref="Search.BooleanScorer"/>). In
/// this case we just .Next() on base and .Advance() on
/// the dim filters.
/// </summary>
private void DoQueryFirstScoring(ICollector collector, DocIdSetIterator[] disis,
ICollector[] sidewaysCollectors, IBits[] bits, ICollector[] bitsSidewaysCollectors)
{
//if (DEBUG) {
// System.out.println(" doQueryFirstScoring");
//}
int docID = baseScorer.DocID;
while (docID != DocsEnum.NO_MORE_DOCS)
{
ICollector failedCollector = null;
for (int i = 0; i < disis.Length; i++)
{
// TODO: should we sort this 2nd dimension of
// docsEnums from most frequent to least?
DocIdSetIterator disi = disis[i];
if (disi != null && disi.DocID < docID)
{
disi.Advance(docID);
}
if (disi == null || disi.DocID > docID)
{
if (failedCollector != null)
{
// More than one dim fails on this document, so
// it's neither a hit nor a near-miss; move to
// next doc:
docID = baseScorer.NextDoc();
goto nextDocContinue;
}
else
{
failedCollector = sidewaysCollectors[i];
}
}
}
// TODO: for the "non-costly Bits" we really should
// have passed them down as acceptDocs, but
// unfortunately we cannot distinguish today betwen
// "bits() is so costly that you should apply it last"
// from "bits() is so cheap that you should apply it
// everywhere down low"
// Fold in Filter Bits last, since they may be costly:
for (int i = 0; i < bits.Length; i++)
{
if (bits[i].Get(docID) == false)
{
if (failedCollector != null)
{
// More than one dim fails on this document, so
// it's neither a hit nor a near-miss; move to
// next doc:
docID = baseScorer.NextDoc();
goto nextDocContinue;
}
else
{
failedCollector = bitsSidewaysCollectors[i];
}
}
}
collectDocID = docID;
// TODO: we could score on demand instead since we are
// daat here:
collectScore = baseScorer.GetScore();
if (failedCollector == null)
{
// Hit passed all filters, so it's "real":
CollectHit(collector, sidewaysCollectors, bitsSidewaysCollectors);
}
else
{
// Hit missed exactly one filter:
CollectNearMiss(failedCollector);
}
docID = baseScorer.NextDoc();
nextDocContinue :;
}
//nextDocBreak:; // Not referenced
}
public virtual void Search(Weight weight, Filter filter, Collector collector, int start, IBoboMapFunctionWrapper mapReduceWrapper)
{
FacetValidator validator = CreateFacetValidator();
int target = 0;
if (filter == null)
{
for (int i = 0; i < _subReaders.Length; i++)
{ // search each subreader
int docStart = start + _docStarts[i];
collector.SetNextReader(_subReaders[i], docStart);
validator.SetNextReader(_subReaders[i], docStart);
Scorer scorer = weight.Scorer(_subReaders[i], true, true);
if (scorer != null)
{
collector.SetScorer(scorer);
target = scorer.NextDoc();
while (target != DocIdSetIterator.NO_MORE_DOCS)
{
if (validator.Validate(target))
{
collector.Collect(target);
target = scorer.NextDoc();
}
else
{
target = validator._nextTarget;
target = scorer.Advance(target);
}
}
}
if (mapReduceWrapper != null)
{
mapReduceWrapper.MapFullIndexReader(_subReaders[i], validator.GetCountCollectors());
}
}
return;
}
for (int i = 0; i < _subReaders.Length; i++)
{
DocIdSet filterDocIdSet = filter.GetDocIdSet(_subReaders[i]);
if (filterDocIdSet == null)
{
return; //shall we use return or continue here ??
}
int docStart = start + _docStarts[i];
collector.SetNextReader(_subReaders[i], docStart);
validator.SetNextReader(_subReaders[i], docStart);
Scorer scorer = weight.Scorer(_subReaders[i], true, false);
if (scorer != null)
{
collector.SetScorer(scorer);
DocIdSetIterator filterDocIdIterator = filterDocIdSet.Iterator(); // CHECKME: use ConjunctionScorer here?
if (filterDocIdIterator == null)
{
continue;
}
int doc = -1;
target = filterDocIdIterator.NextDoc();
if (mapReduceWrapper == null)
{
while (target < DocIdSetIterator.NO_MORE_DOCS)
{
if (doc < target)
{
doc = scorer.Advance(target);
}
if (doc == target) // permitted by filter
{
if (validator.Validate(doc))
{
collector.Collect(doc);
target = filterDocIdIterator.NextDoc();
}
else
{
// skip to the next possible docid
target = filterDocIdIterator.Advance(validator._nextTarget);
}
}
else // doc > target
{
if (doc == DocIdSetIterator.NO_MORE_DOCS)
{
break;
}
target = filterDocIdIterator.Advance(doc);
}
}
}
else
{
//MapReduce wrapper is not null
while (target < DocIdSetIterator.NO_MORE_DOCS)
{
if (doc < target)
{
doc = scorer.Advance(target);
}
if (doc == target) // permitted by filter
{
if (validator.Validate(doc))
{
mapReduceWrapper.MapSingleDocument(doc, _subReaders[i]);
collector.Collect(doc);
target = filterDocIdIterator.NextDoc();
}
else
{
// skip to the next possible docid
target = filterDocIdIterator.Advance(validator._nextTarget);
}
}
else // doc > target
{
if (doc == DocIdSetIterator.NO_MORE_DOCS)
{
break;
}
target = filterDocIdIterator.Advance(doc);
}
}
mapReduceWrapper.FinalizeSegment(_subReaders[i], validator.GetCountCollectors());
}
}
}
}
/// <summary>
/// Does in-place AND of the bits provided by the
/// iterator.
/// </summary>
public void And(DocIdSetIterator iter)
{
if (iter is OpenBitSetIterator && iter.DocID() == -1)
{
OpenBitSetIterator obs = (OpenBitSetIterator)iter;
And(obs.Arr, obs.Words);
// advance after last doc that would be accepted if standard
// iteration is used (to exhaust it):
obs.Advance(NumBits);
}
else if (iter is FixedBitSetIterator && iter.DocID() == -1)
{
FixedBitSetIterator fbs = (FixedBitSetIterator)iter;
And(fbs.bits, fbs.NumWords);
// advance after last doc that would be accepted if standard
// iteration is used (to exhaust it):
fbs.Advance(NumBits);
}
else
{
if (NumBits == 0)
{
return;
}
int disiDoc, bitSetDoc = NextSetBit(0);
while (bitSetDoc != -1 && (disiDoc = iter.Advance(bitSetDoc)) < NumBits)
{
Clear(bitSetDoc, disiDoc);
disiDoc++;
bitSetDoc = (disiDoc < NumBits) ? NextSetBit(disiDoc) : -1;
}
if (bitSetDoc != -1)
{
Clear(bitSetDoc, NumBits);
}
}
}
public virtual void Collect(int doc)
{
// System.out.println("C " + doc);
if (doc > groupEndDocID)
{
// Group changed
if (subDocUpto != 0)
{
ProcessGroup();
}
groupEndDocID = lastDocPerGroupBits.Advance(doc);
//System.out.println(" adv " + groupEndDocID + " " + lastDocPerGroupBits);
subDocUpto = 0;
groupCompetes = !queueFull;
}
totalHitCount++;
// Always cache doc/score within this group:
if (subDocUpto == pendingSubDocs.Length)
{
pendingSubDocs = ArrayUtil.Grow(pendingSubDocs);
}
pendingSubDocs[subDocUpto] = doc;
if (needsScores)
{
if (subDocUpto == pendingSubScores.Length)
{
pendingSubScores = ArrayUtil.Grow(pendingSubScores);
}
pendingSubScores[subDocUpto] = scorer.GetScore();
}
subDocUpto++;
if (groupCompetes)
{
if (subDocUpto == 1)
{
if (Debugging.AssertsEnabled)
{
Debugging.Assert(!queueFull);
}
//System.out.println(" init copy to bottomSlot=" + bottomSlot);
foreach (FieldComparer fc in comparers)
{
fc.Copy(bottomSlot, doc);
fc.SetBottom(bottomSlot);
}
topGroupDoc = doc;
}
else
{
// Compare to bottomSlot
for (int compIDX = 0; ; compIDX++)
{
int c = reversed[compIDX] * comparers[compIDX].CompareBottom(doc);
if (c < 0)
{
// Definitely not competitive -- done
return;
}
else if (c > 0)
{
// Definitely competitive.
break;
}
else if (compIDX == compIDXEnd)
{
// Ties with bottom, except we know this docID is
// > docID in the queue (docs are visited in
// order), so not competitive:
return;
}
}
//System.out.println(" best w/in group!");
foreach (FieldComparer fc in comparers)
{
fc.Copy(bottomSlot, doc);
// Necessary because some comparers cache
// details of bottom slot; this forces them to
// re-cache:
fc.SetBottom(bottomSlot);
}
topGroupDoc = doc;
}
}
else
{
// We're not sure this group will make it into the
// queue yet
for (int compIDX = 0; ; compIDX++)
{
int c = reversed[compIDX] * comparers[compIDX].CompareBottom(doc);
if (c < 0)
{
// Definitely not competitive -- done
//System.out.println(" doc doesn't compete w/ top groups");
return;
}
else if (c > 0)
{
// Definitely competitive.
break;
}
else if (compIDX == compIDXEnd)
{
// Ties with bottom, except we know this docID is
// > docID in the queue (docs are visited in
// order), so not competitive:
//System.out.println(" doc doesn't compete w/ top groups");
return;
}
}
groupCompetes = true;
foreach (FieldComparer fc in comparers)
{
fc.Copy(bottomSlot, doc);
// Necessary because some comparers cache
// details of bottom slot; this forces them to
// re-cache:
fc.SetBottom(bottomSlot);
}
topGroupDoc = doc;
//System.out.println(" doc competes w/ top groups");
}
}
public virtual void Search(Weight weight, Filter filter, ICollector collector, int start, IBoboMapFunctionWrapper mapReduceWrapper)
{
FacetValidator validator = CreateFacetValidator();
int target = 0;
IndexReader reader = this.IndexReader;
IndexReaderContext indexReaderContext = reader.Context;
if (filter == null)
{
for (int i = 0; i < m_subReaders.Length; i++)
{
AtomicReaderContext atomicContext = indexReaderContext.Children == null
? (AtomicReaderContext)indexReaderContext
: (AtomicReaderContext)(indexReaderContext.Children.Get(i));
int docStart = start;
// NOTE: This code calls an internal constructor. Apparently, this was in the same namespace as Lucene,
// but was added to this project, which presumably allows you to call internal constructors in Java.
// In .NET, we can just use Activator.CreateInstance. Not great, but this code will be removed
// when applying commit https://github.com/senseidb/bobo/commit/924c8579d90dbb5d56103976d39b47daa2242ef3
// which includes several major changes after the 4.0.2 release.
// atomicContext = AtomicReaderContextUtil.UpdateDocBase(atomicContext, docStart);
object[] args = new object[] { (CompositeReaderContext)null, atomicContext.AtomicReader, 0, 0, 0, docStart };
Type[] constructorSignature = { typeof(CompositeReaderContext), typeof(AtomicReader), typeof(int), typeof(int), typeof(int), typeof(int) };
var constr = typeof(AtomicReaderContext).GetTypeInfo().DeclaredConstructors
.Single(constructor =>
constructor.GetParameters()
.Select(parameter => parameter.ParameterType)
.SequenceEqual(constructorSignature));
atomicContext = (AtomicReaderContext)constr.Invoke(args);
if (reader is BoboMultiReader)
{
docStart = start + ((BoboMultiReader)reader).SubReaderBase(i);
}
collector.SetNextReader(atomicContext);
validator.SetNextReader(m_subReaders[i], docStart);
// NOTE: The Weight.Scorer method lost the scoreDocsInOrder and topScorer parameters between
// Lucene 4.3.0 and 4.8.0. They are not used by BoboBrowse anyway, so the code here diverges
// from the original Java source to remove these two parameters.
// Scorer scorer = weight.Scorer(atomicContext, true, true, _subReaders[i].LiveDocs);
Scorer scorer = weight.GetScorer(atomicContext, m_subReaders[i].LiveDocs);
if (scorer != null)
{
collector.SetScorer(scorer);
target = scorer.NextDoc();
while (target != DocIdSetIterator.NO_MORE_DOCS)
{
if (validator.Validate(target))
{
collector.Collect(target);
target = scorer.NextDoc();
}
else
{
target = validator.m_nextTarget;
target = scorer.Advance(target);
}
}
}
if (mapReduceWrapper != null)
{
mapReduceWrapper.MapFullIndexReader(m_subReaders[i], validator.GetCountCollectors());
}
}
return;
}
for (int i = 0; i < m_subReaders.Length; i++)
{
AtomicReaderContext atomicContext = indexReaderContext.Children == null
? (AtomicReaderContext)indexReaderContext
: (AtomicReaderContext)(indexReaderContext.Children.Get(i));
DocIdSet filterDocIdSet = filter.GetDocIdSet(atomicContext, m_subReaders[i].LiveDocs);
if (filterDocIdSet == null)
{
return; //shall we use return or continue here ??
}
int docStart = start;
if (reader is BoboMultiReader)
{
docStart = start + ((BoboMultiReader)reader).SubReaderBase(i);
}
collector.SetNextReader(atomicContext);
validator.SetNextReader(m_subReaders[i], docStart);
// NOTE: The Weight.Scorer method lost the scoreDocsInOrder and topScorer parameters between
// Lucene 4.3.0 and 4.8.0. They are not used by BoboBrowse anyway, so the code here diverges
// from the original Java source to remove these two parameters.
// Scorer scorer = weight.Scorer(atomicContext, true, false, _subReaders[i].LiveDocs);
Scorer scorer = weight.GetScorer(atomicContext, m_subReaders[i].LiveDocs);
if (scorer != null)
{
collector.SetScorer(scorer);
DocIdSetIterator filterDocIdIterator = filterDocIdSet.GetIterator(); // CHECKME: use ConjunctionScorer here?
if (filterDocIdIterator == null)
{
continue;
}
int doc = -1;
target = filterDocIdIterator.NextDoc();
if (mapReduceWrapper == null)
{
while (target < DocIdSetIterator.NO_MORE_DOCS)
{
if (doc < target)
{
doc = scorer.Advance(target);
}
if (doc == target) // permitted by filter
{
if (validator.Validate(doc))
{
collector.Collect(doc);
target = filterDocIdIterator.NextDoc();
}
else
{
// skip to the next possible docid
target = filterDocIdIterator.Advance(validator.m_nextTarget);
}
}
else // doc > target
{
if (doc == DocIdSetIterator.NO_MORE_DOCS)
{
break;
}
target = filterDocIdIterator.Advance(doc);
}
}
}
else
{
//MapReduce wrapper is not null
while (target < DocIdSetIterator.NO_MORE_DOCS)
{
if (doc < target)
{
doc = scorer.Advance(target);
}
if (doc == target) // permitted by filter
{
if (validator.Validate(doc))
{
mapReduceWrapper.MapSingleDocument(doc, m_subReaders[i]);
collector.Collect(doc);
target = filterDocIdIterator.NextDoc();
}
else
{
// skip to the next possible docid
target = filterDocIdIterator.Advance(validator.m_nextTarget);
}
}
else // doc > target
{
if (doc == DocIdSetIterator.NO_MORE_DOCS)
{
break;
}
target = filterDocIdIterator.Advance(doc);
}
}
mapReduceWrapper.FinalizeSegment(m_subReaders[i], validator.GetCountCollectors());
}
}
}
}