Java Spans.start方法代码示例

import org.apache.lucene.search.spans.Spans; //导入方法依赖的package包/类
/**
 * Constructs a CandidateSpan for the given Span.
 * 
 * @param span
 *            a Span
 * @throws IOException
 */
public CandidateSpan (Spans span) throws IOException {
    this.doc = span.doc();
    this.start = span.start();
    this.end = span.end();
    this.cost = span.cost();

    this.payloads = new ArrayList<>();
    if (span.isPayloadAvailable()) {
        setPayloads(span.getPayload());
    }
    if (span instanceof SimpleSpans) {
        SimpleSpans temp = (SimpleSpans) span;
        this.spanId = temp.getSpanId();
        this.hasSpanId = temp.hasSpanId;
    }
    else if (span instanceof ClassSpans) {
        this.spanId = ((ClassSpans) span).getNumber();
        this.hasSpanId = true;
    }
}
 

import org.apache.lucene.search.spans.Spans; //导入方法依赖的package包/类
/**
 * Advances the element spans until encountering the given span.
 * 
 * @param span
 *            a span
 * @return <code>true</code> if such an element is found,
 *         <code>false</code>
 *         if the span is not in an element.
 * @throws IOException
 */
private boolean advanceElementTo (Spans span) throws IOException {
    while (hasMoreElements && elements.doc() == currentDocNum
            && elements.start() < span.end()) {

        if (span.start() >= elements.start()
                && span.end() <= elements.end()) {
            return true;
        }
        elementList.add(new CandidateSpan(elements, elementPosition));
        hasMoreElements = elements.next();
        elementPosition++;
    }

    return false; // invalid
}
 

import org.apache.lucene.search.spans.Spans; //导入方法依赖的package包/类
/**
 * Advances the <em>not-attributes</em> to be in the same or
 * greater
 * document number than referentSpans' document number. If a
 * <em>not-attribute</em> is in the same document, it is advanced
 * to be in
 * the same as or greater start position than the current
 * referentSpan.
 * 
 * @throws IOException
 */
private void advanceNotAttributes (Spans referentSpans) throws IOException {

    for (AttributeSpans a : notAttributeList) {
        // advance the doc# of not AttributeSpans
        // logger.info("a "+a.start());
        while (!a.isFinish() && a.doc() <= referentSpans.doc()) {

            if (a.doc() == referentSpans.doc()
                    && a.start() >= referentSpans.start())
                break;

            if (!a.next())
                a.setFinish(true);
        }
    }
}
 

import org.apache.lucene.search.spans.Spans; //导入方法依赖的package包/类
/**
 * Tells if the given span is in an element distance unit, or not,
 * by
 * advancing the element distance unit to the span position.
 * 
 * @param span
 *            a span
 * @return <code>true</code> if the element distance unit can be
 *         advanced to
 *         contain the given span, <code>false</code> otherwise.
 * @throws IOException
 */
private boolean advanceElementTo (Spans span) throws IOException {
    while (hasMoreElements && elements.doc() == currentDocNum
            && elements.start() < span.end()) {

        if (span.start() >= elements.start()
                && span.end() <= elements.end()) {
            return true;
        }

        hasMoreElements = elements.next();
        elementPosition++;
    }
    return false;
}
 

import org.apache.lucene.search.spans.Spans; //导入方法依赖的package包/类
/**
 * Advance elements until encountering a span within the given
 * document.
 * 
 * @return true iff an element containing the span, is found.
 */
private boolean advanceElementTo (Spans span) throws IOException {
    while (hasMoreElements && elements.doc() == candidateListDocNum
            && elements.start() < span.end()) {

        if (span.start() >= elements.start()
                && span.end() <= elements.end()) {
            return true;
        }

        hasMoreElements = elements.next();
        elementPosition++;
    }
    return false;
}
 

import org.apache.lucene.search.spans.Spans; //导入方法依赖的package包/类
/**
 * Finds the element position of the specified span in the element
 * list or by advancing the element spans until encountering the
 * span.
 * 
 * @param span
 *            a Span
 * @return the element position
 * @throws IOException
 */
private int findElementPosition (Spans span) throws IOException {
    // Check in the element list
    if (!elementList.isEmpty() && span.end() <= elementList
            .get(elementList.size() - 1).getEnd()) {

        for (CandidateSpan e : elementList)
            if (e.getEnd() >= span.end() && e.getStart() <= span.start()) {
                return e.getPosition();
            }
        return -1; // The span is not in an element.
    }

    return (advanceElementTo(span) ? elementPosition : -1);
}
 

import org.apache.lucene.search.spans.Spans; //导入方法依赖的package包/类
/**
 * Tells if the target and candidate spans are not too far from
 * each other
 * (within the maximum distance).
 * 
 * @param target
 *            a target span
 * @param candidate
 *            a candidate span
 * @return <code>true</code> if the target and candidate spans are
 *         within
 *         the maximum distance, <code>false</code> otherwise.
 */
protected boolean isWithinMaxDistance (CandidateSpan target,
        Spans candidate) {
    // left candidate
    if (candidate.end() < target.getStart()
            && candidate.end() + maxDistance <= target.getStart()) {
        return false;
    }
    // right candidate
    if (candidate.start() > target.getEnd()
            && target.getEnd() + maxDistance <= candidate.start()) {
        return false;
    }
    return true;
}
 

import org.apache.lucene.search.spans.Spans; //导入方法依赖的package包/类
public int _constellation (Spans a, Spans b) {

        // Constellation checks are
        // optimized for lazy loading,
        // i.e. trying to minimize callings of end()

        // A starts after B
        if (a.start() > b.start()) {

            // if (this.vector & next_b(SUCCEEDS_DIRECTLY) > 0)

            // Don't call end() on A
            if (a.start() == b.end())
                return SUCCEEDS_DIRECTLY;

            if (a.start() > b.end())
                return SUCCEEDS;

            // a) Check if match is possible
            // b) Check if mext is possible on A

            // Call end() on A
            else if (a.end() == b.end()) {
                return ALIGNS_RIGHT;
            }

            else if (a.end() < b.end()) {
                return IS_WITHIN;
            };

            // a.end() > b.end() &&
            // a.start() < b.end()
            return OVERLAPS_RIGHT;
        }

        // A starts before B
        else if (a.start() < b.start()) {

            // Don't call end() on b
            if (a.end() == b.start()) {
                return PRECEDES_DIRECTLY;
            }

            else if (a.end() < b.start()) {
                return PRECEDES;
            }

            // Call end() on B
            else if (a.end() == b.end()) {
                return ENDS_WITH;
            }

            else if (a.end() > b.end()) {
                return IS_AROUND;
            };

            // a.end() > b.start()
            return OVERLAPS_LEFT;
        }

        // A and B start at the same position
        // a.start() == b.start()
        else if (a.end() > b.end()) {
            return STARTS_WITH;
        }
        else if (a.end() < b.end()) {
            return ALIGNS_LEFT;
        };

        // a.end() == b.end()
        return MATCHES;
    }