| Methods Summary |
|---|
| private void | addToList(org.apache.lucene.search.spans.NearSpans$SpansCell cell)
if (last != null) { // add next to end of list
last.next = cell;
} else
first = cell;
last = cell;
cell.next = null;
|
| private boolean | atMatch()
return (min().doc() == max.doc())
&& checkSlop()
&& (!inOrder || matchIsOrdered());
|
| private boolean | checkSlop()
int matchLength = max.end() - min().start();
return (matchLength - totalLength) <= slop;
|
| public int | doc() return min().doc();
|
| public int | end() return max.end();
|
| private boolean | firstNonOrderedNextToPartialList()
/* Creates a partial list consisting of first non ordered and earlier.
* Returns first non ordered .next().
*/
last = first = null;
int orderedIndex = 0;
while (queue.top() != null) {
SpansCell cell = (SpansCell)queue.pop();
addToList(cell);
if (cell.index == orderedIndex) {
orderedIndex++;
} else {
return cell.next();
// FIXME: continue here, rename to eg. checkOrderedMatch():
// when checkSlop() and not ordered, repeat cell.next().
// when checkSlop() and ordered, add to list and repeat queue.pop()
// without checkSlop(): no match, rebuild the queue from the partial list.
// When queue is empty and checkSlop() and ordered there is a match.
}
}
throw new RuntimeException("Unexpected: ordered");
|
| private void | firstToLast()
last.next = first; // move first to end of list
last = first;
first = first.next;
last.next = null;
|
| private void | initList(boolean next)
for (int i = 0; more && i < ordered.size(); i++) {
SpansCell cell = (SpansCell)ordered.get(i);
if (next)
more = cell.next(); // move to first entry
if (more) {
addToList(cell); // add to list
}
}
|
| private void | listToQueue()
queue.clear(); // rebuild queue
partialListToQueue();
|
| private boolean | matchIsOrdered()
int lastStart = -1;
for (int i = 0; i < ordered.size(); i++) {
int start = ((SpansCell)ordered.get(i)).start();
if (!(start > lastStart))
return false;
lastStart = start;
}
return true;
|
| private org.apache.lucene.search.spans.NearSpans$SpansCell | min() return (SpansCell)queue.top();
|
| public boolean | next()
if (firstTime) {
initList(true);
listToQueue(); // initialize queue
firstTime = false;
} else if (more) {
more = min().next(); // trigger further scanning
if (more)
queue.adjustTop(); // maintain queue
}
while (more) {
boolean queueStale = false;
if (min().doc() != max.doc()) { // maintain list
queueToList();
queueStale = true;
}
// skip to doc w/ all clauses
while (more && first.doc() < last.doc()) {
more = first.skipTo(last.doc()); // skip first upto last
firstToLast(); // and move it to the end
queueStale = true;
}
if (!more) return false;
// found doc w/ all clauses
if (queueStale) { // maintain the queue
listToQueue();
queueStale = false;
}
if (atMatch())
return true;
// trigger further scanning
if (inOrder && checkSlop()) {
/* There is a non ordered match within slop and an ordered match is needed. */
more = firstNonOrderedNextToPartialList();
if (more) {
partialListToQueue();
}
} else {
more = min().next();
if (more) {
queue.adjustTop(); // maintain queue
}
}
}
return false; // no more matches
|
| private void | partialListToQueue()
for (SpansCell cell = first; cell != null; cell = cell.next) {
queue.put(cell); // add to queue from list
}
|
| private void | queueToList()
last = first = null;
while (queue.top() != null) {
addToList((SpansCell)queue.pop());
}
|
| public boolean | skipTo(int target)
if (firstTime) { // initialize
initList(false);
for (SpansCell cell = first; more && cell!=null; cell=cell.next) {
more = cell.skipTo(target); // skip all
}
if (more) {
listToQueue();
}
firstTime = false;
} else { // normal case
while (more && min().doc() < target) { // skip as needed
more = min().skipTo(target);
if (more)
queue.adjustTop();
}
}
if (more) {
if (atMatch()) // at a match?
return true;
return next(); // no, scan
}
return false;
|
| public int | start() return min().start();
|
| public java.lang.String | toString()
return "spans("+query.toString()+")@"+
(firstTime?"START":(more?(doc()+":"+start()+"-"+end()):"END"));
|
