public override void Replay(ICollector other)
{
ReplayInit(other);
int curUpto = 0;
int curbase = 0;
int chunkUpto = 0;
m_curDocs = EMPTY_INT32_ARRAY;
foreach (SegStart seg in m_cachedSegs)
{
other.SetNextReader(seg.ReaderContext);
while (curbase + curUpto < seg.End)
{
if (curUpto == m_curDocs.Length)
{
curbase += m_curDocs.Length;
m_curDocs = m_cachedDocs[chunkUpto];
chunkUpto++;
curUpto = 0;
}
other.Collect(m_curDocs[curUpto++]);
}
}
}
public virtual void SetNextReader(AtomicReaderContext context)
{
m_in.SetNextReader(context);
m_segmentSorted = SortingMergePolicy.IsSorted(context.AtomicReader, m_sort);
m_segmentTotalCollect = m_segmentSorted ? m_numDocsToCollect : int.MaxValue;
numCollected = 0;
}
/// <summary>
/// Lower-level search API.
///
/// <para/>
/// <seealso cref="ICollector.Collect(int)"/> is called for every document.
///
/// <para/>
/// NOTE: this method executes the searches on all given leaves exclusively.
/// To search across all the searchers leaves use <see cref="m_leafContexts"/>.
/// </summary>
/// <param name="leaves">
/// The searchers leaves to execute the searches on </param>
/// <param name="weight">
/// To match documents </param>
/// <param name="collector">
/// To receive hits </param>
/// <exception cref="BooleanQuery.TooManyClausesException"> If a query would exceed
/// <see cref="BooleanQuery.MaxClauseCount"/> clauses. </exception>
protected virtual void Search(IList <AtomicReaderContext> leaves, Weight weight, ICollector collector)
{
// TODO: should we make this
// threaded...? the Collector could be sync'd?
// always use single thread:
foreach (AtomicReaderContext ctx in leaves) // search each subreader
{
try
{
collector.SetNextReader(ctx);
}
catch (CollectionTerminatedException)
{
// there is no doc of interest in this reader context
// continue with the following leaf
continue;
}
BulkScorer scorer = weight.GetBulkScorer(ctx, !collector.AcceptsDocsOutOfOrder, ctx.AtomicReader.LiveDocs);
if (scorer != null)
{
try
{
scorer.Score(collector);
}
catch (CollectionTerminatedException)
{
// collection was terminated prematurely
// continue with the following leaf
}
}
}
}
public virtual void SetNextReader(AtomicReaderContext context)
{
m_other.SetNextReader(context);
if (lastReaderContext != null)
{
m_cachedSegs.Add(new SegStart(lastReaderContext, m_base + m_upto));
}
lastReaderContext = context;
}
public virtual void TestCollector()
{
// Tests that the collector delegates calls to input collectors properly.
// Tests that the collector handles some null collectors well. If it
// doesn't, an NPE would be thrown.
DummyCollector[] dcs = new DummyCollector[] { new DummyCollector(), new DummyCollector() };
ICollector c = MultiCollector.Wrap(dcs);
Assert.IsTrue(c.AcceptsDocsOutOfOrder);
c.Collect(1);
c.SetNextReader(null);
c.SetScorer(null);
foreach (DummyCollector dc in dcs)
{
Assert.IsTrue(dc.AcceptsDocsOutOfOrderCalled);
Assert.IsTrue(dc.CollectCalled);
Assert.IsTrue(dc.SetNextReaderCalled);
Assert.IsTrue(dc.SetScorerCalled);
}
}
public virtual void TestNullCollectors()
{
// Tests that the collector rejects all null collectors.
try
{
MultiCollector.Wrap(null, null);
Assert.Fail("only null collectors should not be supported");
}
catch (Exception e) when(e.IsIllegalArgumentException())
{
// expected
}
// Tests that the collector handles some null collectors well. If it
// doesn't, an NPE would be thrown.
ICollector c = MultiCollector.Wrap(new DummyCollector(), null, new DummyCollector());
Assert.IsTrue(c is MultiCollector);
Assert.IsTrue(c.AcceptsDocsOutOfOrder);
c.Collect(1);
c.SetNextReader(null);
c.SetScorer(null);
}
public virtual void SetNextReader(AtomicReaderContext context)
{
collector.SetNextReader(context);
}
public virtual void SetNextReader(AtomicReaderContext context)
{
DocBase = context.DocBase;
Other.SetNextReader(context);
}
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());
}
}
}
}
public override bool Score(ICollector collector, int maxDoc)
{
if (maxDoc != int.MaxValue)
{
throw new ArgumentOutOfRangeException(nameof(maxDoc), "maxDoc must be System.Int32.MaxValue"); // LUCENENET specific - changed from IllegalArgumentException to ArgumentOutOfRangeException (.NET convention)
}
//if (DEBUG) {
// System.out.println("\nscore: reader=" + context.reader());
//}
//System.out.println("score r=" + context.reader());
FakeScorer scorer = new FakeScorer(this);
collector.SetScorer(scorer);
if (drillDownCollector != null)
{
drillDownCollector.SetScorer(scorer);
drillDownCollector.SetNextReader(context);
}
foreach (DocsAndCost dim in dims)
{
dim.sidewaysCollector.SetScorer(scorer);
dim.sidewaysCollector.SetNextReader(context);
}
// TODO: if we ever allow null baseScorer ... it will
// mean we DO score docs out of order ... hmm, or if we
// change up the order of the conjuntions below
if (Debugging.AssertsEnabled)
{
Debugging.Assert(baseScorer != null);
}
// some scorers, eg ReqExlScorer, can hit NPE if cost is called after nextDoc
long baseQueryCost = baseScorer.GetCost();
int numDims = dims.Length;
long drillDownCost = 0;
for (int dim = 0; dim < numDims; dim++)
{
DocIdSetIterator disi = dims[dim].disi;
if (dims[dim].bits is null && disi != null)
{
drillDownCost += disi.GetCost();
}
}
long drillDownAdvancedCost = 0;
if (numDims > 1 && dims[1].disi != null)
{
drillDownAdvancedCost = dims[1].disi.GetCost();
}
// Position all scorers to their first matching doc:
baseScorer.NextDoc();
int numBits = 0;
foreach (DocsAndCost dim in dims)
{
if (dim.disi != null)
{
dim.disi.NextDoc();
}
else if (dim.bits != null)
{
numBits++;
}
}
IBits[] bits = new IBits[numBits];
ICollector[] bitsSidewaysCollectors = new ICollector[numBits];
DocIdSetIterator[] disis = new DocIdSetIterator[numDims - numBits];
ICollector[] sidewaysCollectors = new ICollector[numDims - numBits];
int disiUpto = 0;
int bitsUpto = 0;
for (int dim = 0; dim < numDims; dim++)
{
DocIdSetIterator disi = dims[dim].disi;
if (dims[dim].bits is null)
{
disis[disiUpto] = disi;
sidewaysCollectors[disiUpto] = dims[dim].sidewaysCollector;
disiUpto++;
}
else
{
bits[bitsUpto] = dims[dim].bits;
bitsSidewaysCollectors[bitsUpto] = dims[dim].sidewaysCollector;
bitsUpto++;
}
}
/*
* System.out.println("\nbaseDocID=" + baseScorer.docID() + " est=" + estBaseHitCount);
* System.out.println(" maxDoc=" + context.reader().maxDoc());
* System.out.println(" maxCost=" + maxCost);
* System.out.println(" dims[0].freq=" + dims[0].freq);
* if (numDims > 1) {
* System.out.println(" dims[1].freq=" + dims[1].freq);
* }
*/
if (bitsUpto > 0 || scoreSubDocsAtOnce || baseQueryCost < drillDownCost / 10)
{
//System.out.println("queryFirst: baseScorer=" + baseScorer + " disis.length=" + disis.length + " bits.length=" + bits.length);
DoQueryFirstScoring(collector, disis, sidewaysCollectors, bits, bitsSidewaysCollectors);
}
else if (numDims > 1 && (dims[1].disi is null || drillDownAdvancedCost < baseQueryCost / 10))
{
//System.out.println("drillDownAdvance");
DoDrillDownAdvanceScoring(collector, disis, sidewaysCollectors);
}
