public ICollection <byte[]> GetPayload()
{
List <byte[]> result = null;
PayloadSpans theTop = (PayloadSpans)Top();
if (theTop != null && theTop.IsPayloadAvailable())
{
result = new List <byte[]>(theTop.GetPayload());
}
return(result);
}
private bool InitSpanQueue(int target)
{
queue = new SpanQueue(enclosingInstance, Enclosing_Instance.clauses.Count);
System.Collections.IEnumerator i = Enclosing_Instance.clauses.GetEnumerator();
while (i.MoveNext())
{
PayloadSpans spans = ((SpanQuery)i.Current).GetPayloadSpans(reader);
if (((target == -1) && spans.Next()) || ((target != -1) && spans.SkipTo(target)))
{
queue.Put(spans);
}
}
return(queue.Size() != 0);
}
public bool IsPayloadAvailable()
{
PayloadSpans top = Top();
return(top != null && top.IsPayloadAvailable());
}
private void InitBlock(Lucene.Net.Index.IndexReader reader, SpanFirstQuery enclosingInstance)
{
this.reader = reader;
this.enclosingInstance = enclosingInstance;
spans = Enclosing_Instance.match.GetPayloadSpans(reader);
}
/// <summary>The subSpans are ordered in the same doc, so there is a possible match.
/// Compute the slop while making the match as short as possible by advancing
/// all subSpans except the last one in reverse order.
/// </summary>
private bool ShrinkToAfterShortestMatch()
{
matchStart = subSpans[subSpans.Length - 1].Start();
matchEnd = subSpans[subSpans.Length - 1].End();
if (subSpans[subSpans.Length - 1].IsPayloadAvailable())
{
SupportClass.CollectionsSupport.AddAll(subSpans[subSpans.Length - 1].GetPayload(), matchPayload);
}
int matchSlop = 0;
int lastStart = matchStart;
int lastEnd = matchEnd;
for (int i = subSpans.Length - 2; i >= 0; i--)
{
PayloadSpans prevSpans = subSpans[i];
if (subSpans[i].IsPayloadAvailable())
{
matchPayload.InsertRange(0, subSpans[i].GetPayload());
}
int prevStart = prevSpans.Start();
int prevEnd = prevSpans.End();
while (true)
{
// Advance prevSpans until after (lastStart, lastEnd)
if (!prevSpans.Next())
{
inSameDoc = false;
more = false;
break; // Check remaining subSpans for final match.
}
else if (matchDoc != prevSpans.Doc())
{
inSameDoc = false; // The last subSpans is not advanced here.
break; // Check remaining subSpans for last match in this document.
}
else
{
int ppStart = prevSpans.Start();
int ppEnd = prevSpans.End(); // Cannot avoid invoking .end()
if (!DocSpansOrdered(ppStart, ppEnd, lastStart, lastEnd))
{
break; // Check remaining subSpans.
}
else
{
// prevSpans still before (lastStart, lastEnd)
prevStart = ppStart;
prevEnd = ppEnd;
}
}
}
System.Diagnostics.Debug.Assert(prevStart <= matchStart);
if (matchStart > prevEnd)
{
// Only non overlapping spans add to slop.
matchSlop += (matchStart - prevEnd);
}
/* Do not break on (matchSlop > allowedSlop) here to make sure
* that subSpans[0] is advanced after the match, if any.
*/
matchStart = prevStart;
lastStart = prevStart;
lastEnd = prevEnd;
}
return(matchSlop <= allowedSlop); // ordered and allowed slop
}
private void InitBlock(Lucene.Net.Index.IndexReader reader, SpanFirstQuery enclosingInstance)
{
this.reader = reader;
this.enclosingInstance = enclosingInstance;
spans = Enclosing_Instance.match.GetPayloadSpans(reader);
}
public SpansCell(NearSpansUnordered enclosingInstance, PayloadSpans spans, int index)
{
InitBlock(enclosingInstance);
this.spans = spans;
this.index = index;
}
public SpansCell(NearSpansUnordered enclosingInstance, PayloadSpans spans, int index)
{
InitBlock(enclosingInstance);
this.spans = spans;
this.index = index;
}
private void InitBlock(Lucene.Net.Index.IndexReader reader, SpanNotQuery enclosingInstance)
{
this.reader = reader;
this.enclosingInstance = enclosingInstance;
includeSpans = Enclosing_Instance.include.GetPayloadSpans(reader);
excludeSpans = Enclosing_Instance.exclude.GetSpans(reader);
moreExclude = excludeSpans.Next();
}
