/// <summary>Advance to non excluded doc.
/// <br/>On entry:
/// <ul>
/// <li>reqScorer != null, </li>
/// <li>exclScorer != null, </li>
/// <li>reqScorer was advanced once via next() or skipTo()
/// and reqScorer.doc() may still be excluded.</li>
/// </ul>
/// 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);
}
public virtual void AssertContainsDocId(System.String msg, DocIdSet docIdSet, int docId)
{
DocIdSetIterator it = docIdSet.Iterator(null);
Assert.IsTrue(it.Advance(docId, null) != DocIdSetIterator.NO_MORE_DOCS, msg);
Assert.IsTrue(it.DocID() == docId, msg);
}
public override Explanation Explain(IndexReader ir, int i)
{
Explanation inner = weight.Explain(ir, i);
if (Enclosing_Instance.GetBoost() != 1)
{
Explanation preBoost = inner;
inner = new Explanation(inner.GetValue() * Enclosing_Instance.GetBoost(), "product of:");
inner.AddDetail(new Explanation(Enclosing_Instance.GetBoost(), "boost"));
inner.AddDetail(preBoost);
}
Filter f = Enclosing_Instance.filter;
DocIdSet docIdSet = f.GetDocIdSet(ir);
DocIdSetIterator docIdSetIterator = docIdSet == null?DocIdSet.EMPTY_DOCIDSET.Iterator() : docIdSet.Iterator();
if (docIdSetIterator == null)
{
docIdSetIterator = DocIdSet.EMPTY_DOCIDSET.Iterator();
}
if (docIdSetIterator.Advance(i) == i)
{
return(inner);
}
else
{
Explanation result = new Explanation(0.0f, "failure to match filter: " + f.ToString());
result.AddDetail(inner);
return(result);
}
}
private void SearchWithFilter(IndexReader reader, Weight weight, Filter filter, Collector collector, IState state)
{
System.Diagnostics.Debug.Assert(filter != null);
Scorer scorer = weight.Scorer(reader, true, false, state);
if (scorer == null)
{
return;
}
int docID = scorer.DocID();
System.Diagnostics.Debug.Assert(docID == -1 || docID == DocIdSetIterator.NO_MORE_DOCS);
// CHECKME: use ConjunctionScorer here?
DocIdSet filterDocIdSet = filter.GetDocIdSet(reader, state);
if (filterDocIdSet == null)
{
// this means the filter does not accept any documents.
return;
}
DocIdSetIterator filterIter = filterDocIdSet.Iterator(state);
if (filterIter == null)
{
// this means the filter does not accept any documents.
return;
}
int filterDoc = filterIter.NextDoc(state);
int scorerDoc = scorer.Advance(filterDoc, state);
collector.SetScorer(scorer);
while (true)
{
if (scorerDoc == filterDoc)
{
// Check if scorer has exhausted, only before collecting.
if (scorerDoc == DocIdSetIterator.NO_MORE_DOCS)
{
break;
}
collector.Collect(scorerDoc, state);
filterDoc = filterIter.NextDoc(state);
scorerDoc = scorer.Advance(filterDoc, state);
}
else if (scorerDoc > filterDoc)
{
filterDoc = filterIter.Advance(scorerDoc, state);
}
else
{
scorerDoc = scorer.Advance(filterDoc, state);
}
}
}
private int AdvanceToNextCommonDoc()
{
for (; ;)
{
if (m_secondaryDoc < m_primaryDoc)
{
m_secondaryDoc = secondary.Advance(m_primaryDoc);
}
else if (m_secondaryDoc == m_primaryDoc)
{
return(m_primaryDoc);
}
else
{
m_primaryDoc = primary.Advance(m_secondaryDoc);
}
}
}
internal int AdvanceToNextCommonDoc()
{
for (; ;)
{
if (SecondaryDoc < PrimaryDoc)
{
SecondaryDoc = Secondary.Advance(PrimaryDoc);
}
else if (SecondaryDoc == PrimaryDoc)
{
return(PrimaryDoc);
}
else
{
PrimaryDoc = Primary.Advance(SecondaryDoc);
}
}
}
public virtual void TestFilteredDocIdSet()
{
int maxdoc = 10;
DocIdSet innerSet = new AnonymousClassDocIdSet_Renamed_Class(maxdoc, this);
DocIdSet filteredSet = new AnonymousClassFilteredDocIdSet(this, innerSet);
DocIdSetIterator iter = filteredSet.Iterator(null);
System.Collections.ArrayList list = new System.Collections.ArrayList();
int doc = iter.Advance(3, null);
if (doc != DocIdSetIterator.NO_MORE_DOCS)
{
list.Add((System.Int32)doc);
while ((doc = iter.NextDoc(null)) != DocIdSetIterator.NO_MORE_DOCS)
{
list.Add((System.Int32)doc);
}
}
int[] docs = new int[list.Count];
int c = 0;
System.Collections.IEnumerator intIter = list.GetEnumerator();
while (intIter.MoveNext())
{
docs[c++] = ((System.Int32)intIter.Current);
}
int[] answer = new int[] { 4, 6, 8 };
bool same = CollectionsHelper.Equals(answer, docs);
if (!same)
{
System.Console.Out.WriteLine("answer: " + _TestUtil.ArrayToString(answer));
System.Console.Out.WriteLine("gotten: " + _TestUtil.ArrayToString(docs));
Assert.Fail();
}
}
public override Explanation Explain(AtomicReaderContext ir, int i)
{
Explanation inner = weight.Explain(ir, i);
Filter f = outerInstance.filter;
DocIdSet docIdSet = f.GetDocIdSet(ir, ir.AtomicReader.LiveDocs);
DocIdSetIterator docIdSetIterator = docIdSet == null?DocIdSetIterator.GetEmpty() : docIdSet.GetIterator();
if (docIdSetIterator == null)
{
docIdSetIterator = DocIdSetIterator.GetEmpty();
}
if (docIdSetIterator.Advance(i) == i)
{
return(inner);
}
else
{
Explanation result = new Explanation(0.0f, "failure to match filter: " + f.ToString());
result.AddDetail(inner);
return(result);
}
}
public virtual void TestFilteredDocIdSet()
{
const int maxdoc = 10;
DocIdSet innerSet = new DocIdSetAnonymousClass(this, maxdoc);
DocIdSet filteredSet = new FilteredDocIdSetAnonymousClass(this, innerSet);
DocIdSetIterator iter = filteredSet.GetIterator();
IList <int> list = new JCG.List <int>();
int doc = iter.Advance(3);
if (doc != DocIdSetIterator.NO_MORE_DOCS)
{
list.Add(Convert.ToInt32(doc));
while ((doc = iter.NextDoc()) != DocIdSetIterator.NO_MORE_DOCS)
{
list.Add(Convert.ToInt32(doc));
}
}
int[] docs = new int[list.Count];
int c = 0;
using IEnumerator <int> intIter = list.GetEnumerator();
while (intIter.MoveNext())
{
docs[c++] = intIter.Current;
}
int[] answer = new int[] { 4, 6, 8 };
bool same = Arrays.Equals(answer, docs);
if (!same)
{
Console.WriteLine("answer: " + Arrays.ToString(answer));
Console.WriteLine("gotten: " + Arrays.ToString(docs));
Assert.Fail();
}
}
public override int Advance(int target)
{
doc = m_innerIter.Advance(target);
if (doc != NO_MORE_DOCS)
{
if (Match(doc))
{
return(doc);
}
else
{
while ((doc = m_innerIter.NextDoc()) != NO_MORE_DOCS)
{
if (Match(doc))
{
return(doc);
}
}
return(doc);
}
}
return(doc);
}
public override int Advance(int target, IState state)
{
doc = internalInnerIter.Advance(target, state);
if (doc != NO_MORE_DOCS)
{
if (Match(doc))
{
return(doc);
}
else
{
while ((doc = internalInnerIter.NextDoc(state)) != NO_MORE_DOCS)
{
if (Match(doc))
{
return(doc);
}
}
return(doc);
}
}
return(doc);
}
public override int Advance(int target)
{
return(docIdSetIterator.Advance(target));
}
public override int Advance(int target, IState state)
{
return(docIdSetIterator.Advance(target, state));
}
public override bool SkipTo(int target)
{
return(docIdSetIterator.Advance(target) != NO_MORE_DOCS);
}
