Renamed CandidateSpans to CandidateSpan.
diff --git a/src/main/java/de/ids_mannheim/korap/query/spans/AttributeSpans.java b/src/main/java/de/ids_mannheim/korap/query/spans/AttributeSpans.java
index 2127e35..3792f7e 100644
--- a/src/main/java/de/ids_mannheim/korap/query/spans/AttributeSpans.java
+++ b/src/main/java/de/ids_mannheim/korap/query/spans/AttributeSpans.java
@@ -226,8 +226,8 @@
* attributes with smaller spanIds come first on the list.
*
* */
- class CandidateAttributeSpan extends CandidateSpans implements
- Comparable<CandidateSpans> {
+ class CandidateAttributeSpan extends CandidateSpan implements
+ Comparable<CandidateSpan> {
private short spanId;
private int elementEnd;
@@ -268,7 +268,7 @@
}
@Override
- public int compareTo(CandidateSpans o) {
+ public int compareTo(CandidateSpan o) {
CandidateAttributeSpan cs = (CandidateAttributeSpan) o;
if (this.spanId == cs.spanId)
return 0;
diff --git a/src/main/java/de/ids_mannheim/korap/query/spans/DistanceExclusionSpans.java b/src/main/java/de/ids_mannheim/korap/query/spans/DistanceExclusionSpans.java
index cff3100..2bc0cd4 100644
--- a/src/main/java/de/ids_mannheim/korap/query/spans/DistanceExclusionSpans.java
+++ b/src/main/java/de/ids_mannheim/korap/query/spans/DistanceExclusionSpans.java
@@ -10,136 +10,152 @@
import de.ids_mannheim.korap.query.SpanDistanceQuery;
-/** Span enumeration of the first spans which do NOT occur
- * together with the second spans within a range of distance.
+/**
+ * Span enumeration of spans (the firstSpans) which do <em>not</em> occur
+ * together with other spans (the secondSpans) within a range of distance.
*
- * @author margaretha
+ * @author margaretha
* */
-public class DistanceExclusionSpans extends DistanceSpans{
-
- private int minDistance, maxDistance;
- private boolean isOrdered;
- private boolean hasMoreSecondSpans;
+public class DistanceExclusionSpans extends DistanceSpans {
- public DistanceExclusionSpans(SpanDistanceQuery query,
- AtomicReaderContext context, Bits acceptDocs,
- Map<Term, TermContext> termContexts, boolean isOrdered)
- throws IOException {
- super(query, context, acceptDocs, termContexts);
- minDistance = query.getMinDistance();
- maxDistance = query.getMaxDistance();
- this.isOrdered = isOrdered;
- hasMoreSpans = firstSpans.next();
- hasMoreSecondSpans = secondSpans.next();
- }
+ private int minDistance, maxDistance;
+ private boolean isOrdered;
+ private boolean hasMoreSecondSpans;
- @Override
- protected boolean advance() throws IOException {
-
- while(hasMoreSpans){
- if (hasMoreSecondSpans) forwardSecondSpans();
-
- if (findMatch()){
- hasMoreSpans = firstSpans.next();
- return true;
- }
- hasMoreSpans = firstSpans.next();
- }
- return false;
- }
+ /**
+ * Constructs DistanceExclusionSpans for the specified
+ * {@link SpanDistanceQuery}.
+ *
+ * @param query a SpanDistanceQuery
+ * @param context
+ * @param acceptDocs
+ * @param termContexts
+ * @param isOrdered a boolean flag representing the value <code>true</code>
+ * if the spans must occur in order, <code>false</code> otherwise.
+ * @throws IOException
+ */
+ public DistanceExclusionSpans(SpanDistanceQuery query,
+ AtomicReaderContext context, Bits acceptDocs,
+ Map<Term, TermContext> termContexts) throws IOException {
+ super(query, context, acceptDocs, termContexts);
+ minDistance = query.getMinDistance();
+ maxDistance = query.getMaxDistance();
+ this.isOrdered = query.isOrdered();
+ hasMoreSpans = firstSpans.next();
+ hasMoreSecondSpans = secondSpans.next();
+ }
- private void forwardSecondSpans() throws IOException{
-
- if (secondSpans.doc() < firstSpans.doc()){
- hasMoreSecondSpans = secondSpans.skipTo(firstSpans.doc());
- }
-
- // skip the secondSpan to the right side of the firstspan
- while (hasMoreSecondSpans && secondSpans.doc() == firstSpans.doc() &&
- firstSpans.start() >= secondSpans.end()){
+ @Override
+ protected boolean advance() throws IOException {
- // the firstspan is within maxDistance
- if (!isOrdered && calculateActualDistance() <= maxDistance){
- break;
- }
- hasMoreSecondSpans = secondSpans.next();
-
- }
- }
-
- /** Calculate the distance / difference between a firstspan and
- * a secondspan positions.
- *
- * @return distance
- * */
- private int calculateActualDistance(){
- // right secondSpan
- if (firstSpans.end() <= secondSpans.start())
- return secondSpans.start() - firstSpans.end() +1;
- // left secondSpan
- return firstSpans.start() - secondSpans.end() +1;
- }
-
- /** Check the distance between the current first span and second span
- * against the min and max distance constraints.
- *
- * @return true if the distance between the first and the second spans
- * are smaller as the minimum distance or bigger than the max
- * distance.
- * */
- private boolean findMatch() throws IOException {
- if (!hasMoreSecondSpans || secondSpans.doc() > firstSpans.doc()){
- setMatchProperties();
- return true;
- }
- if (minDistance == 0 &&
- firstSpans.start() < secondSpans.end() &&
- secondSpans.start() < firstSpans.end()){
- return false;
- }
-
- int actualDistance = calculateActualDistance();
- if (actualDistance < minDistance || actualDistance > maxDistance){
- setMatchProperties();
- return true;
- }
-
- return false;
- }
-
- /** Set the current firstspan as the match
- *
- * */
- private void setMatchProperties() throws IOException{
- matchDocNumber = firstSpans.doc();
- matchStartPosition = firstSpans.start();
- matchEndPosition = firstSpans.end();
-
- if (collectPayloads && firstSpans.isPayloadAvailable())
- matchPayload.addAll(firstSpans.getPayload());
-
- setMatchFirstSpan(new CandidateSpans(firstSpans));
-
-// log.trace("doc# {}, start {}, end {}",
-// matchDocNumber,
-// matchStartPosition,
-// matchEndPosition);
- }
+ while (hasMoreSpans) {
+ if (hasMoreSecondSpans)
+ forwardSecondSpans();
- @Override
- public boolean skipTo(int target) throws IOException {
- if (hasMoreSpans && firstSpans.doc() < target){
- if (!firstSpans.skipTo(target)){
- hasMoreSpans = false;
- return false;
- }
- }
- return advance();
- }
+ if (findMatch()) {
+ hasMoreSpans = firstSpans.next();
+ return true;
+ }
+ hasMoreSpans = firstSpans.next();
+ }
+ return false;
+ }
- @Override
- public long cost() {
- return firstSpans.cost() + secondSpans.cost();
- }
-
+ /**
+ * Advance the second span until it occurs on the right side of the first
+ * span.
+ *
+ * @throws IOException
+ */
+ private void forwardSecondSpans() throws IOException {
+
+ if (secondSpans.doc() < firstSpans.doc()) {
+ hasMoreSecondSpans = secondSpans.skipTo(firstSpans.doc());
+ }
+
+ // skip the secondSpan to the right side of the firstSpan
+ while (hasMoreSecondSpans && secondSpans.doc() == firstSpans.doc()
+ && firstSpans.start() >= secondSpans.end()) {
+
+ // the firstspan is within maxDistance
+ if (!isOrdered && calculateActualDistance() <= maxDistance) {
+ break;
+ }
+ hasMoreSecondSpans = secondSpans.next();
+ }
+ }
+
+ /**
+ * Calculate the distance / difference between a firstspan and a secondspan
+ * positions.
+ *
+ * @return distance the difference between the positions of a firstspan and
+ * a secondspan.
+ * */
+ private int calculateActualDistance() {
+ // right secondSpan
+ if (firstSpans.end() <= secondSpans.start())
+ return secondSpans.start() - firstSpans.end() + 1;
+ // left secondSpan
+ return firstSpans.start() - secondSpans.end() + 1;
+ }
+
+ /**
+ * Check the distance between the current first span and second span against
+ * the min and max distance constraints.
+ *
+ * @return true if the distance between the first and the second spans are
+ * smaller as the minimum distance or bigger than the max distance.
+ */
+ private boolean findMatch() throws IOException {
+ if (!hasMoreSecondSpans || secondSpans.doc() > firstSpans.doc()) {
+ setMatchProperties();
+ return true;
+ }
+ if (minDistance == 0 && firstSpans.start() < secondSpans.end()
+ && secondSpans.start() < firstSpans.end()) {
+ return false;
+ }
+
+ int actualDistance = calculateActualDistance();
+ if (actualDistance < minDistance || actualDistance > maxDistance) {
+ setMatchProperties();
+ return true;
+ }
+
+ return false;
+ }
+
+ /**
+ * Set the current firstspan as the current match.
+ *
+ * @throws IOException
+ */
+ private void setMatchProperties() throws IOException {
+ matchDocNumber = firstSpans.doc();
+ matchStartPosition = firstSpans.start();
+ matchEndPosition = firstSpans.end();
+
+ if (collectPayloads && firstSpans.isPayloadAvailable())
+ matchPayload.addAll(firstSpans.getPayload());
+
+ setMatchFirstSpan(new CandidateSpan(firstSpans));
+ }
+
+ @Override
+ public boolean skipTo(int target) throws IOException {
+ if (hasMoreSpans && firstSpans.doc() < target) {
+ if (!firstSpans.skipTo(target)) {
+ hasMoreSpans = false;
+ return false;
+ }
+ }
+ return advance();
+ }
+
+ @Override
+ public long cost() {
+ return firstSpans.cost() + secondSpans.cost();
+ }
+
}
diff --git a/src/main/java/de/ids_mannheim/korap/query/spans/DistanceSpans.java b/src/main/java/de/ids_mannheim/korap/query/spans/DistanceSpans.java
index 2a0e447..8559405 100644
--- a/src/main/java/de/ids_mannheim/korap/query/spans/DistanceSpans.java
+++ b/src/main/java/de/ids_mannheim/korap/query/spans/DistanceSpans.java
@@ -13,84 +13,130 @@
import de.ids_mannheim.korap.query.SpanDistanceQuery;
import de.ids_mannheim.korap.query.SpanMultipleDistanceQuery;
-/** DistanceSpan is a base class for enumeration of span matches,
- * whose two child spans have a specific range of distance (within
- * a min and a max distance).
+/**
+ * DistanceSpan is a base class for enumeration of span matches, whose two child
+ * spans have a specific range of distance (within a min and a max distance) and
+ * other constraints (i.e. order and co-occurrence) depending on the
+ * {@link SpanDistanceQuery}. All distance related spans extends this class.
+ *
+ * @see DistanceExclusionSpans
+ * @see ElementDistanceExclusionSpans
+ * @see OrderedDistanceSpans
+ * @see UnorderedDistanceSpans
+ * @see MultipleDistanceSpans
*
* @author margaretha
* */
-public abstract class DistanceSpans extends SimpleSpans{
+public abstract class DistanceSpans extends SimpleSpans {
- protected CandidateSpans matchFirstSpan,matchSecondSpan;
- protected Logger log = LoggerFactory.getLogger(DistanceSpans.class);
- protected boolean exclusion; // because MultipleDistanceQuery doesn't have this property
-
- public DistanceSpans(SpanDistanceQuery query,
- AtomicReaderContext context, Bits acceptDocs,
- Map<Term, TermContext> termContexts) throws IOException {
- super(query, context, acceptDocs, termContexts);
- exclusion = query.isExclusion();
- }
-
- public DistanceSpans(SpanMultipleDistanceQuery query,
- AtomicReaderContext context, Bits acceptDocs,
- Map<Term, TermContext> termContexts) throws IOException {
- super(query, context, acceptDocs, termContexts);
- }
-
- @Override
- public boolean next() throws IOException {
- isStartEnumeration=false;
- matchPayload.clear();
- return advance();
- }
+ protected CandidateSpan matchFirstSpan, matchSecondSpan;
+ protected Logger log = LoggerFactory.getLogger(DistanceSpans.class);
+ protected boolean exclusion; // for MultipleDistanceQuery
-
- /** Find the next span match.
- * @return true iff a span match is available.
- * */
- protected abstract boolean advance() throws IOException;
+ /**
+ * Constructs a DistanceSpans enumeration for the given
+ * {@link SpanDistanceQuery}.
+ *
+ * @param query a SpanDistanceQuery
+ * @param context
+ * @param acceptDocs
+ * @param termContexts
+ * @throws IOException
+ */
+ public DistanceSpans(SpanDistanceQuery query, AtomicReaderContext context,
+ Bits acceptDocs, Map<Term, TermContext> termContexts)
+ throws IOException {
+ super(query, context, acceptDocs, termContexts);
+ exclusion = query.isExclusion();
+ }
-/* *//** Find the same doc shared by element, firstspan and secondspan.
- * @return true iff such a doc is found.
- * *//*
- protected boolean findSameDoc(Spans x,
- Spans y, Spans e) throws IOException{
-
- while (hasMoreSpans) {
- if (ensureSameDoc(x, y) &&
- e.doc() == x.doc()){
- return true;
- }
- if (!ensureSameDoc(e,y)){
- return false;
- };
- }
- return false;
- }*/
-
- public CandidateSpans getMatchFirstSpan() {
- return matchFirstSpan;
- }
+ /**
+ * Constructs a DistanceSpans enumeration for the given
+ * {@link SpanMultipleDistanceQuery}.
+ *
+ * @param query a SpanMultipleDistanceQuery
+ * @param context
+ * @param acceptDocs
+ * @param termContexts
+ * @throws IOException
+ */
+ public DistanceSpans(SpanMultipleDistanceQuery query,
+ AtomicReaderContext context, Bits acceptDocs,
+ Map<Term, TermContext> termContexts) throws IOException {
+ super(query, context, acceptDocs, termContexts);
+ }
- public void setMatchFirstSpan(CandidateSpans matchFirstSpan) {
- this.matchFirstSpan = matchFirstSpan;
- }
+ @Override
+ public boolean next() throws IOException {
+ isStartEnumeration = false;
+ matchPayload.clear();
+ return advance();
+ }
- public CandidateSpans getMatchSecondSpan() {
- return matchSecondSpan;
- }
+ /**
+ * Advances the current span enumeration to the next span match.
+ *
+ * @return <code>true</code> if a span match is available,
+ * <code>false</code> otherwise.
+ * */
+ protected abstract boolean advance() throws IOException;
- public void setMatchSecondSpan(CandidateSpans matchSecondSpan) {
- this.matchSecondSpan = matchSecondSpan;
- }
+ /**
+ * Returns the first span of the current match.
+ *
+ * @return the first span of the current match.
+ */
+ public CandidateSpan getMatchFirstSpan() {
+ return matchFirstSpan;
+ }
- public boolean isExclusion() {
- return exclusion;
- }
+ /**
+ * Sets the first span of the current match.
+ *
+ * @param matchFirstSpan the first span of the current match.
+ */
+ public void setMatchFirstSpan(CandidateSpan matchFirstSpan) {
+ this.matchFirstSpan = matchFirstSpan;
+ }
- public void setExclusion(boolean exclusion) {
- this.exclusion = exclusion;
- }
+ /**
+ * Returns the second span of the current match.
+ *
+ * @return the second span of the current match.
+ */
+ public CandidateSpan getMatchSecondSpan() {
+ return matchSecondSpan;
+ }
+
+ /**
+ * Sets the second span of the current match.
+ *
+ * @param matchSecondSpan the second span of the current match.
+ */
+ public void setMatchSecondSpan(CandidateSpan matchSecondSpan) {
+ this.matchSecondSpan = matchSecondSpan;
+ }
+
+ /**
+ * Tells if the second span must occur together with the first span, or not.
+ *
+ * @return <code>true</code> if the second span must <em>not</em> occur
+ * together with the first span, <code>false</code> otherwise.
+ */
+ public boolean isExclusion() {
+ return exclusion;
+ }
+
+ /**
+ * Sets <code>true</code> if the second span must <em>not</em> occur
+ * together with the first span, <code>false</code> otherwise.
+ *
+ * @param exclusion a boolean with the value <code>true</code> if the second
+ * span must <em>not</em> occur together with the first span,
+ * <code>false</code> otherwise.
+ */
+ public void setExclusion(boolean exclusion) {
+ this.exclusion = exclusion;
+ }
}
diff --git a/src/main/java/de/ids_mannheim/korap/query/spans/ElementDistanceExclusionSpans.java b/src/main/java/de/ids_mannheim/korap/query/spans/ElementDistanceExclusionSpans.java
index 24008bd..3e701b6 100644
--- a/src/main/java/de/ids_mannheim/korap/query/spans/ElementDistanceExclusionSpans.java
+++ b/src/main/java/de/ids_mannheim/korap/query/spans/ElementDistanceExclusionSpans.java
@@ -14,241 +14,361 @@
import de.ids_mannheim.korap.query.SpanDistanceQuery;
-/** Span enumeration of the first spans which do NOT occur together
- * with the second spans within a range of some element-based distance
- * (sentence or paragraph). Note: The element distance unit does not
- * overlap to each other.
+/**
+ * Span enumeration of spans (firstSpans) which do <em>not</em> occur together
+ * with other spans (secondSpans) on the right side, within a range of an
+ * element-based distance (i.e. a sentence or a paragraph as the distance unit).
+ * If the query requires that the spans are ordered, then the firstSpans must
+ * occur before the secondSpans. In this class, firstSpans are also referred to
+ * as target spans and second spans as candidate spans.<br/>
+ * <br/>
+ * Note: The element distance unit does not overlap to each other.
*
- * @author margaretha
+ * @author margaretha
* */
-public class ElementDistanceExclusionSpans extends DistanceSpans{
+public class ElementDistanceExclusionSpans extends DistanceSpans {
- private Spans elements;
- private boolean hasMoreElements;
- private int elementPosition;
-
- private boolean isOrdered;
- private boolean hasMoreSecondSpans;
-
- protected List<CandidateSpans> candidateList, targetList;
- private int currentDocNum;
-
- private int minDistance, maxDistance;
- private int firstSpanPostion;
+ private Spans elements;
+ private boolean hasMoreElements;
+ private int elementPosition;
- public static final boolean DEBUG = false;
+ private boolean isOrdered;
+ private boolean hasMoreSecondSpans;
- public ElementDistanceExclusionSpans(SpanDistanceQuery query,
- AtomicReaderContext context, Bits acceptDocs,
- Map<Term, TermContext> termContexts, boolean isOrdered)
- throws IOException {
- super(query, context, acceptDocs, termContexts);
-
- elements = query.getElementQuery().
- getSpans(context, acceptDocs, termContexts);
- hasMoreElements = elements.next();
- hasMoreSpans = firstSpans.next() && hasMoreElements;
- hasMoreSecondSpans = secondSpans.next();
-
- elementPosition=0;
- this.isOrdered = isOrdered;
- candidateList = new ArrayList<CandidateSpans>();
- targetList = new ArrayList<CandidateSpans>();
- currentDocNum = firstSpans.doc();
-
- minDistance = query.getMinDistance();
- maxDistance = query.getMaxDistance();
- }
+ // other first spans occurred between the current target and the second
+ // spans
+ protected List<CandidateSpan> targetList;
+ // secondSpans occurring near the firstSpans
+ protected List<CandidateSpan> candidateList;
+ private int currentDocNum;
- @Override
- protected boolean advance() throws IOException {
- while(!targetList.isEmpty() || (hasMoreSpans && ensureSameDoc(firstSpans, elements))){
- if (!targetList.isEmpty()){
- if (isTargetValid()) return true;
- else continue;
- }
- if (checkFirstSpan()) return true;
- }
- return false;
- }
-
- private boolean isTargetValid() throws IOException{
- CandidateSpans target = targetList.get(0);
- targetList.remove(0);
- firstSpanPostion = target.getPosition();
- filterCandidateList(firstSpanPostion);
- collectRightCandidates();
-
- if (isWithinDistance()){
- return false;
- }
- setMatchProperties(target);
- return true;
- }
-
- private boolean checkFirstSpan() throws IOException{
- if (firstSpans.doc() != currentDocNum){
- currentDocNum = firstSpans.doc();
- candidateList.clear();
- }
-
- if (hasMoreSecondSpans) {
- if (secondSpans.doc() == firstSpans.doc()){
- return (findMatch() ? true : false);
- }
- else if (secondSpans.doc() < firstSpans.doc()){
- hasMoreSecondSpans = secondSpans.skipTo(firstSpans.doc());
- return false;
- }
- }
- return (isFirstSpanValid() ? true : false);
- }
-
- private boolean isFirstSpanValid() throws IOException{
- if (candidateList.isEmpty()){
- if (isFirstSpanInElement()){
- setMatchProperties(new CandidateSpans(firstSpans,elementPosition));
- hasMoreSpans = firstSpans.next();
- return true;
- }
- hasMoreSpans = firstSpans.next();
- return false;
- }
- return (findMatch() ? true : false);
- }
-
- 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;
- }
+ private int minDistance, maxDistance;
+ private int firstSpanPostion;
- private boolean findMatch() throws IOException {
- if (!isOrdered) collectLeftCandidates();
-
- if (isFirstSpanInElement()){
- CandidateSpans target = new CandidateSpans(firstSpans,elementPosition);
- hasMoreSpans = firstSpans.next();
- // Checking the secondspans in the left side
- if (!isOrdered && isWithinDistance()) return false;
- // Checking the secondspans in the right side
- collectRightCandidates();
- if (isWithinDistance()) return false;
-
- setMatchProperties(target);
- return true;
- }
- hasMoreSpans = firstSpans.next();
- return false;
- }
-
- private void collectRightCandidates() throws IOException{
- while (hasMoreSecondSpans && secondSpans.doc() == currentDocNum){
-
- if (elementPosition > firstSpanPostion+maxDistance){
- break;
- }
- if (hasMoreSpans && firstSpans.start() < secondSpans.start() &&
- firstSpans.doc() == currentDocNum){
- if (advanceElementTo(firstSpans)){
- targetList.add(new CandidateSpans(firstSpans, elementPosition));
- }
- hasMoreSpans = firstSpans.next();
- continue;
- }
-
- if (advanceElementTo(secondSpans)){
- candidateList.add(new CandidateSpans(secondSpans,elementPosition));
- }
- hasMoreSecondSpans = secondSpans.next();
- }
- }
-
- private void collectLeftCandidates() throws IOException{
- while(hasMoreSecondSpans && secondSpans.doc() == firstSpans.doc() &&
- secondSpans.start() < firstSpans.end()){
- if (advanceElementTo(secondSpans)){
- candidateList.add(new CandidateSpans(secondSpans,elementPosition));
- filterCandidateList(elementPosition);
- }
- hasMoreSecondSpans = secondSpans.next();
- }
- }
-
- private boolean isWithinDistance(){
- int actualDistance;
- for (CandidateSpans cs: candidateList){
- actualDistance = cs.getPosition() - firstSpanPostion;
- if (!isOrdered) actualDistance = Math.abs(actualDistance);
-
- if (minDistance <= actualDistance && actualDistance <= maxDistance)
- return true;
- }
- return false;
- }
-
- private boolean isFirstSpanInElement() throws IOException {
- if (advanceElementTo(firstSpans)){
- firstSpanPostion = elementPosition;
- filterCandidateList(firstSpanPostion);
- return true;
- }
- return false;
- }
-
- private void filterCandidateList(int position){
-
- Iterator<CandidateSpans> i = candidateList.iterator();
- CandidateSpans cs;
- while(i.hasNext()){
- cs = i.next();
- if (cs.getPosition() == position ||
- cs.getPosition()+maxDistance >= position){
- break;
- }
- i.remove();
- }
- }
-
- private void setMatchProperties(CandidateSpans match) throws IOException{
- matchDocNumber = match.getDoc();
- matchStartPosition = match.getStart();
- matchEndPosition = match.getEnd();
-
- if (collectPayloads && match.getPayloads() != null)
- matchPayload.addAll(match.getPayloads());
-
- setMatchFirstSpan(match);
+ /**
+ * Constructs ElementDistanceExclusionSpans from the specified
+ * {@link SpanDistanceQuery}.
+ *
+ * @param query a SpanDistanceQuery
+ * @param context
+ * @param acceptDocs
+ * @param termContexts
+ * @throws IOException
+ */
+ public ElementDistanceExclusionSpans(SpanDistanceQuery query,
+ AtomicReaderContext context, Bits acceptDocs,
+ Map<Term, TermContext> termContexts) throws IOException {
+ super(query, context, acceptDocs, termContexts);
- if (DEBUG)
- log.trace("doc# {}, start {}, end {}",matchDocNumber,matchStartPosition,
- matchEndPosition);
- }
+ elements = query.getElementQuery().getSpans(context, acceptDocs,
+ termContexts);
+ hasMoreElements = elements.next();
+ hasMoreSpans = firstSpans.next() && hasMoreElements;
+ hasMoreSecondSpans = secondSpans.next();
- @Override
- public boolean skipTo(int target) throws IOException {
- if (hasMoreSpans && firstSpans.doc() < target){
- if (!firstSpans.skipTo(target)){
- hasMoreSpans = false;
- return false;
- }
- }
- return advance();
- }
+ elementPosition = 0;
+ this.isOrdered = query.isOrdered();
+ candidateList = new ArrayList<CandidateSpan>();
+ targetList = new ArrayList<CandidateSpan>();
+ currentDocNum = firstSpans.doc();
- @Override
- public long cost() {
- return elements.cost() + firstSpans.cost() + secondSpans.cost();
- }
+ minDistance = query.getMinDistance();
+ maxDistance = query.getMaxDistance();
+ }
+
+ @Override
+ protected boolean advance() throws IOException {
+ while (!targetList.isEmpty()
+ || (hasMoreSpans && ensureSameDoc(firstSpans, elements))) {
+ if (!targetList.isEmpty()) {
+ if (isFirstTargetValid())
+ return true;
+ else
+ continue;
+ }
+ if (findMatch())
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * Tells if the first target from the target list is a match.
+ *
+ * @return <code>true</code> if the first target from the target list is a
+ * match, <code>false</code> otherwise.
+ * @throws IOException
+ */
+ private boolean isFirstTargetValid() throws IOException {
+ CandidateSpan target = targetList.get(0);
+ targetList.remove(0);
+ firstSpanPostion = target.getPosition();
+ filterCandidateList(firstSpanPostion);
+ collectRightCandidates();
+
+ if (isWithinDistance()) {
+ return false;
+ }
+ setMatchProperties(target);
+ return true;
+ }
+
+ /**
+ * Validate if the current firstSpan is a match.
+ *
+ * @return <code>true</code> if a match is found, <code>false</code>
+ * otherwise.
+ * @throws IOException
+ */
+ private boolean findMatch() throws IOException {
+ if (firstSpans.doc() != currentDocNum) {
+ currentDocNum = firstSpans.doc();
+ candidateList.clear();
+ }
+
+ if (hasMoreSecondSpans) {
+ if (secondSpans.doc() == firstSpans.doc()) {
+ return (isFirstSpanValid() ? true : false);
+ } else if (secondSpans.doc() < firstSpans.doc()) {
+ hasMoreSecondSpans = secondSpans.skipTo(firstSpans.doc());
+ return false;
+ }
+ }
+
+ // return (isFirstSpanValid() ? true : false);
+
+ if (candidateList.isEmpty()) {
+ if (isFirstSpanInElement()) {
+ setMatchProperties(new CandidateSpan(firstSpans,
+ elementPosition));
+ hasMoreSpans = firstSpans.next();
+ return true;
+ }
+ hasMoreSpans = firstSpans.next();
+ return false;
+ }
+ return (isFirstSpanValid() ? true : false);
+ }
+
+ /**
+ * Tells if the current firstSpan is a match.
+ *
+ * @return <code>true</code> if a match is found, <code>false</code>
+ * otherwise.
+ * @throws IOException <pre>
+ * private boolean isFirstSpanValid() throws IOException {
+ * if (candidateList.isEmpty()) {
+ * if (isFirstSpanInElement()) {
+ * setMatchProperties(new CandidateSpan(firstSpans, elementPosition));
+ * hasMoreSpans = firstSpans.next();
+ * return true;
+ * }
+ * hasMoreSpans = firstSpans.next();
+ * return false;
+ * }
+ * return (findMatch() ? true : false);
+ * }
+ * </pre>
+ */
+
+ /**
+ * 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;
+ }
+
+ /**
+ * Tells if the current firstSpan is a match.
+ *
+ * @return <code>true</code> if a match is found, <code>false</code>
+ * otherwise.
+ * @throws IOException
+ */
+ private boolean isFirstSpanValid() throws IOException {
+ if (!isOrdered)
+ collectLeftCandidates();
+
+ if (isFirstSpanInElement()) {
+ CandidateSpan target = new CandidateSpan(firstSpans,
+ elementPosition);
+ hasMoreSpans = firstSpans.next();
+ // Checking if the secondspans in the *left* side are not within the
+ // distance range
+ if (!isOrdered && isWithinDistance())
+ return false;
+ // Checking if the secondspans in the *right* side are not within
+ // the distance range
+ collectRightCandidates();
+ if (isWithinDistance())
+ return false;
+
+ setMatchProperties(target);
+ return true;
+ }
+ hasMoreSpans = firstSpans.next();
+ return false;
+ }
+
+ /**
+ * Collects all second spans (candidates) on the right side of the current
+ * first span (target) position. At the same time, also collects all other
+ * first spans occurring before the second spans.
+ *
+ * @throws IOException
+ */
+ private void collectRightCandidates() throws IOException {
+ while (hasMoreSecondSpans && secondSpans.doc() == currentDocNum) {
+
+ if (elementPosition > firstSpanPostion + maxDistance) {
+ break;
+ }
+ // stores all first spans occurring before the current second span
+ // in the target list.
+ if (hasMoreSpans && firstSpans.start() < secondSpans.start()
+ && firstSpans.doc() == currentDocNum) {
+ if (advanceElementTo(firstSpans)) {
+ targetList.add(new CandidateSpan(firstSpans,
+ elementPosition));
+ }
+ hasMoreSpans = firstSpans.next();
+ continue;
+ }
+ // collects only second spans occurring inside an element
+ if (advanceElementTo(secondSpans)) {
+ candidateList.add(new CandidateSpan(secondSpans,
+ elementPosition));
+ }
+ hasMoreSecondSpans = secondSpans.next();
+ }
+ }
+
+ /**
+ * Collects all the second spans (candidates) occurring before the first
+ * spans, and are within an element distance unit.
+ *
+ * @throws IOException
+ */
+ private void collectLeftCandidates() throws IOException {
+ while (hasMoreSecondSpans && secondSpans.doc() == firstSpans.doc()
+ && secondSpans.start() < firstSpans.end()) {
+ if (advanceElementTo(secondSpans)) {
+ candidateList.add(new CandidateSpan(secondSpans,
+ elementPosition));
+ filterCandidateList(elementPosition);
+ }
+ hasMoreSecondSpans = secondSpans.next();
+ }
+ }
+
+ /**
+ * Tells if there is a candidate span (second span) occurring together with
+ * the target span (firstspan) within the minimum and maximum distance
+ * range.
+ *
+ * @return <code>true</code> if there is a candidate span (second span)
+ * occurring together with the target span (firstspan) within the
+ * minimum and maximum distance range, <code>false</code> otherwise.
+ */
+ private boolean isWithinDistance() {
+ int actualDistance;
+ for (CandidateSpan cs : candidateList) {
+ actualDistance = cs.getPosition() - firstSpanPostion;
+ if (!isOrdered)
+ actualDistance = Math.abs(actualDistance);
+
+ if (minDistance <= actualDistance && actualDistance <= maxDistance)
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * Tells if the current firstSpans is in an element.
+ *
+ * @return <code>true</code> if the current firstSpans in is an element,
+ * <code>false</code> otherwise.
+ * @throws IOException
+ */
+ private boolean isFirstSpanInElement() throws IOException {
+ if (advanceElementTo(firstSpans)) {
+ firstSpanPostion = elementPosition;
+ filterCandidateList(firstSpanPostion);
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * From the candidateList, removes all candidate spans that are too far from
+ * the given target position, and have exactly the same position as the
+ * target position. Only candidate spans occurring within a range of
+ * distance from the target position, are retained.
+ *
+ * @param position target/firstSpan position
+ */
+ private void filterCandidateList(int position) {
+
+ Iterator<CandidateSpan> i = candidateList.iterator();
+ CandidateSpan cs;
+ while (i.hasNext()) {
+ cs = i.next();
+ if (cs.getPosition() == position
+ || cs.getPosition() + maxDistance >= position) {
+ break;
+ }
+ i.remove();
+ }
+ }
+
+ /**
+ * Sets the given target/match CandidateSpan as the current match.
+ *
+ * @param match a target/firstSpan wrapped as a CandidateSpan
+ * @throws IOException
+ */
+ private void setMatchProperties(CandidateSpan match) throws IOException {
+ matchDocNumber = match.getDoc();
+ matchStartPosition = match.getStart();
+ matchEndPosition = match.getEnd();
+
+ if (collectPayloads && match.getPayloads() != null)
+ matchPayload.addAll(match.getPayloads());
+
+ setMatchFirstSpan(match);
+ }
+
+ @Override
+ public boolean skipTo(int target) throws IOException {
+ if (hasMoreSpans && firstSpans.doc() < target) {
+ if (!firstSpans.skipTo(target)) {
+ hasMoreSpans = false;
+ return false;
+ }
+ }
+ return advance();
+ }
+
+ @Override
+ public long cost() {
+ return elements.cost() + firstSpans.cost() + secondSpans.cost();
+ }
}
diff --git a/src/main/java/de/ids_mannheim/korap/query/spans/ElementDistanceSpans.java b/src/main/java/de/ids_mannheim/korap/query/spans/ElementDistanceSpans.java
index 20c9691..229004e 100644
--- a/src/main/java/de/ids_mannheim/korap/query/spans/ElementDistanceSpans.java
+++ b/src/main/java/de/ids_mannheim/korap/query/spans/ElementDistanceSpans.java
@@ -47,7 +47,7 @@
@Override
protected boolean findMatch() throws IOException {
- CandidateSpans candidateSpan = candidateList.get(candidateListIndex);
+ CandidateSpan candidateSpan = candidateList.get(candidateListIndex);
int actualDistance = secondSpanPostion - candidateSpan.getPosition();
// In the same element
@@ -91,7 +91,7 @@
firstSpans.start() < secondSpans.end()){
if (advanceElementTo(firstSpans)){
- candidateList.add(new CandidateSpans(firstSpans,elementPosition));
+ candidateList.add(new CandidateSpan(firstSpans,elementPosition));
filterCandidateList(elementPosition);
}
hasMoreFirstSpans = firstSpans.next();
@@ -124,8 +124,8 @@
* */
private void filterCandidateList(int position){
- Iterator<CandidateSpans> i = candidateList.iterator();
- CandidateSpans cs;
+ Iterator<CandidateSpan> i = candidateList.iterator();
+ CandidateSpan cs;
while(i.hasNext()){
cs = i.next();
if (cs.getPosition() == position ||
@@ -150,7 +150,7 @@
@Override
public long cost() {
- CandidateSpans candidateSpan = candidateList.get(candidateListIndex);
+ CandidateSpan candidateSpan = candidateList.get(candidateListIndex);
return elements.cost() + candidateSpan.getCost() + secondSpans.cost();
}
}
diff --git a/src/main/java/de/ids_mannheim/korap/query/spans/ElementSpans.java b/src/main/java/de/ids_mannheim/korap/query/spans/ElementSpans.java
index 43163c8..8b8d90b 100644
--- a/src/main/java/de/ids_mannheim/korap/query/spans/ElementSpans.java
+++ b/src/main/java/de/ids_mannheim/korap/query/spans/ElementSpans.java
@@ -154,7 +154,7 @@
/** Match candidate for element spans.
* */
- class CandidateElementSpans extends CandidateSpans {
+ class CandidateElementSpans extends CandidateSpan {
private short elementRef;
diff --git a/src/main/java/de/ids_mannheim/korap/query/spans/ExpandedExclusionSpans.java b/src/main/java/de/ids_mannheim/korap/query/spans/ExpandedExclusionSpans.java
index 5cfe210..79c6db4 100644
--- a/src/main/java/de/ids_mannheim/korap/query/spans/ExpandedExclusionSpans.java
+++ b/src/main/java/de/ids_mannheim/korap/query/spans/ExpandedExclusionSpans.java
@@ -24,7 +24,7 @@
private int min, max;
private int direction;
private byte classNumber;
- private List<CandidateSpans> candidateSpans;
+ private List<CandidateSpan> candidateSpans;
private boolean hasMoreNotClause;
private Spans notClause;
@@ -54,7 +54,7 @@
this.notClause = secondSpans;
this.hasMoreNotClause = notClause.next();
- candidateSpans = new ArrayList<CandidateSpans>();
+ candidateSpans = new ArrayList<CandidateSpan>();
hasMoreSpans = firstSpans.next();
}
@@ -69,7 +69,7 @@
while (hasMoreSpans || candidateSpans.size() > 0){
if (candidateSpans.size() > 0){
// set a candidate span as a match
- CandidateSpans cs = candidateSpans.get(0);
+ CandidateSpan cs = candidateSpans.get(0);
matchDocNumber = cs.getDoc();
matchStartPosition = cs.getStart();
matchEndPosition = cs.getEnd();
@@ -103,14 +103,14 @@
private void expandLeft() throws IOException{
//int counter = max;
int maxPos = max;
- CandidateSpans lastNotClause = null;
+ CandidateSpan lastNotClause = null;
while (hasMoreNotClause &&
notClause.start() < firstSpans.start()){
// between max and firstspan.start()
if (notClause.start() >= firstSpans.start() - maxPos){
maxPos = firstSpans.start() - notClause.start() -1;
- lastNotClause = new CandidateSpans(notClause);
+ lastNotClause = new CandidateSpan(notClause);
//counter--;
}
if (!notClause.next()) hasMoreNotClause = false;
@@ -140,13 +140,13 @@
int maxPos = max;
boolean isFound = false;
- CandidateSpans firstNotClause = null;
+ CandidateSpan firstNotClause = null;
//System.out.println("main start:"+firstSpans.start());
while (hasMoreNotClause && notClause.start() < expansionEnd){
// between firstspan.end() and expansionEnd
if (!isFound && notClause.start() >= firstSpans.end()){
maxPos = notClause.start() - firstSpans.end() -1;
- firstNotClause = new CandidateSpans(notClause);
+ firstNotClause = new CandidateSpan(notClause);
isFound = true;
}
if (!notClause.next()) hasMoreNotClause = false;
@@ -173,7 +173,7 @@
throws IOException {
int counter;
int start, end;
- CandidateSpans cs;
+ CandidateSpan cs;
if (direction < 0 ) { // left
counter = maxPos;
while (counter >= min){
@@ -181,7 +181,7 @@
if (start > -1 ){
end = firstSpans.end();
//System.out.println(start+","+end);
- cs = new CandidateSpans(start, end, firstSpans.doc(),
+ cs = new CandidateSpan(start, end, firstSpans.doc(),
firstSpans.cost(),
calculatePayload(start,firstSpans.start())
);
@@ -197,7 +197,7 @@
end = firstSpans.end() + counter;
//System.out.println(start+","+end);
- cs = new CandidateSpans(start, end, firstSpans.doc(),
+ cs = new CandidateSpan(start, end, firstSpans.doc(),
firstSpans.cost(),
calculatePayload(firstSpans.end(), end)
);
diff --git a/src/main/java/de/ids_mannheim/korap/query/spans/ExpandedSpans.java b/src/main/java/de/ids_mannheim/korap/query/spans/ExpandedSpans.java
index 3fd0afe..81032a6 100644
--- a/src/main/java/de/ids_mannheim/korap/query/spans/ExpandedSpans.java
+++ b/src/main/java/de/ids_mannheim/korap/query/spans/ExpandedSpans.java
@@ -21,7 +21,7 @@
private int min, max;
private byte classNumber;
private int direction;
- private List<CandidateSpans> candidateSpans;
+ private List<CandidateSpan> candidateSpans;
private long matchCost;
public ExpandedSpans(SpanExpansionQuery spanExpansionQuery,
@@ -33,7 +33,7 @@
this.direction = spanExpansionQuery.getDirection();
this.classNumber = spanExpansionQuery.getClassNumber();
- candidateSpans = new ArrayList<CandidateSpans>();
+ candidateSpans = new ArrayList<CandidateSpan>();
hasMoreSpans = true;
}
@@ -59,14 +59,14 @@
}
private void setCandidateList() throws IOException {
- CandidateSpans cs;
+ CandidateSpan cs;
int counter, start, end;
if (direction < 0 ){
counter = max;
while (counter >= min ){
start = Math.max(0,firstSpans.start() - counter);
- cs = new CandidateSpans(
+ cs = new CandidateSpan(
start,
firstSpans.end(),
firstSpans.doc(),
@@ -83,7 +83,7 @@
while (counter <= max){
// TODO: How do I know if the end is already too far (over the end of the doc)?
end = firstSpans.end() + counter;
- cs = new CandidateSpans(
+ cs = new CandidateSpan(
firstSpans.start(),
end,
firstSpans.doc(),
@@ -118,7 +118,7 @@
return buffer.array();
}
- private void setMatch(CandidateSpans candidateSpan) {
+ private void setMatch(CandidateSpan candidateSpan) {
matchDocNumber = candidateSpan.getDoc();
matchStartPosition = candidateSpan.getStart();
matchEndPosition = candidateSpan.getEnd();
diff --git a/src/main/java/de/ids_mannheim/korap/query/spans/MultipleDistanceSpans.java b/src/main/java/de/ids_mannheim/korap/query/spans/MultipleDistanceSpans.java
index 52a0964..0dbd06e 100644
--- a/src/main/java/de/ids_mannheim/korap/query/spans/MultipleDistanceSpans.java
+++ b/src/main/java/de/ids_mannheim/korap/query/spans/MultipleDistanceSpans.java
@@ -91,11 +91,11 @@
* */
protected boolean findMatch() throws IOException {
- CandidateSpans xf = x.getMatchFirstSpan();
- CandidateSpans xs = x.getMatchSecondSpan();
+ CandidateSpan xf = x.getMatchFirstSpan();
+ CandidateSpan xs = x.getMatchSecondSpan();
- CandidateSpans yf = y.getMatchFirstSpan();
- CandidateSpans ys = y.getMatchSecondSpan();
+ CandidateSpan yf = y.getMatchFirstSpan();
+ CandidateSpan ys = y.getMatchSecondSpan();
if (x.isExclusion() || y.isExclusion()){
if (xf.getStart() == yf.getStart() && xf.getEnd() == yf.getEnd()){
diff --git a/src/main/java/de/ids_mannheim/korap/query/spans/NextSpans.java b/src/main/java/de/ids_mannheim/korap/query/spans/NextSpans.java
index e03940a..7ebbc46 100644
--- a/src/main/java/de/ids_mannheim/korap/query/spans/NextSpans.java
+++ b/src/main/java/de/ids_mannheim/korap/query/spans/NextSpans.java
@@ -24,8 +24,8 @@
* */
public class NextSpans extends SimpleSpans {
- private List<CandidateSpans> matchList;
- private List<CandidateSpans> candidateList;
+ private List<CandidateSpan> matchList;
+ private List<CandidateSpan> candidateList;
private int candidateListDocNum;
private boolean hasMoreFirstSpan;
@@ -93,8 +93,8 @@
}
private void searchCandidates() throws IOException {
- Iterator<CandidateSpans> i = candidateList.iterator();
- CandidateSpans cs;
+ Iterator<CandidateSpan> i = candidateList.iterator();
+ CandidateSpan cs;
while(i.hasNext()){
cs = i.next();
if (cs.getStart() == firstSpans.end()){
@@ -115,14 +115,14 @@
break;
}
if (secondSpans.start() == firstSpans.end()){
- candidateList.add(new CandidateSpans(secondSpans));
- addMatch(new CandidateSpans(secondSpans));
+ candidateList.add(new CandidateSpan(secondSpans));
+ addMatch(new CandidateSpan(secondSpans));
}
hasMoreSpans = secondSpans.next();
}
}
- private void addMatch(CandidateSpans cs) throws IOException{
+ private void addMatch(CandidateSpan cs) throws IOException{
int start = firstSpans.start();
long cost = firstSpans.cost() + cs.getCost();
@@ -135,7 +135,7 @@
payloads.addAll(cs.getPayloads());
}
- matchList.add(new CandidateSpans(start,cs.getEnd(),candidateListDocNum,cost,
+ matchList.add(new CandidateSpan(start,cs.getEnd(),candidateListDocNum,cost,
payloads));
}
diff --git a/src/main/java/de/ids_mannheim/korap/query/spans/OrderedDistanceSpans.java b/src/main/java/de/ids_mannheim/korap/query/spans/OrderedDistanceSpans.java
index bdf81ef..1dd1a04 100644
--- a/src/main/java/de/ids_mannheim/korap/query/spans/OrderedDistanceSpans.java
+++ b/src/main/java/de/ids_mannheim/korap/query/spans/OrderedDistanceSpans.java
@@ -22,7 +22,7 @@
protected boolean hasMoreFirstSpans;
protected int minDistance,maxDistance;
- protected List<CandidateSpans> candidateList;
+ protected List<CandidateSpan> candidateList;
protected int candidateListIndex;
protected int candidateListDocNum;
@@ -84,11 +84,11 @@
/** Define the properties of a span match.
* */
- protected void setMatchProperties(CandidateSpans candidateSpan,
+ protected void setMatchProperties(CandidateSpan candidateSpan,
boolean isDistanceZero) throws IOException{
setMatchFirstSpan(candidateSpan);
- setMatchSecondSpan(new CandidateSpans(secondSpans));
+ setMatchSecondSpan(new CandidateSpan(secondSpans));
if (isDistanceZero){
matchStartPosition = Math.min(candidateSpan.getStart(), secondSpans.start());
diff --git a/src/main/java/de/ids_mannheim/korap/query/spans/RelationPartSpans.java b/src/main/java/de/ids_mannheim/korap/query/spans/RelationPartSpans.java
index 20fe1de..871298e 100644
--- a/src/main/java/de/ids_mannheim/korap/query/spans/RelationPartSpans.java
+++ b/src/main/java/de/ids_mannheim/korap/query/spans/RelationPartSpans.java
@@ -242,7 +242,7 @@
return 0;
}
- class CandidateRelationSpan extends CandidateSpans implements Comparable<CandidateSpans>{
+ class CandidateRelationSpan extends CandidateSpan implements Comparable<CandidateSpan>{
private int rightStart, rightEnd;
private short leftId, rightId;
@@ -261,7 +261,7 @@
}
@Override
- public int compareTo(CandidateSpans o) {
+ public int compareTo(CandidateSpan o) {
CandidateRelationSpan cs = (CandidateRelationSpan) o;
if (sortRight)
return sortByRight(cs);
diff --git a/src/main/java/de/ids_mannheim/korap/query/spans/RelationSpans.java b/src/main/java/de/ids_mannheim/korap/query/spans/RelationSpans.java
index 380e899..2c4bdb6 100644
--- a/src/main/java/de/ids_mannheim/korap/query/spans/RelationSpans.java
+++ b/src/main/java/de/ids_mannheim/korap/query/spans/RelationSpans.java
@@ -197,7 +197,7 @@
// this.rightId = rightId;
// }
- class CandidateRelationSpan extends CandidateSpans implements Comparable<CandidateSpans>{
+ class CandidateRelationSpan extends CandidateSpan implements Comparable<CandidateSpan>{
private int rightStart, rightEnd;
private short leftId, rightId;
@@ -207,7 +207,7 @@
}
@Override
- public int compareTo(CandidateSpans o) {
+ public int compareTo(CandidateSpan o) {
int sourcePositionComparison = super.compareTo(o);
diff --git a/src/main/java/de/ids_mannheim/korap/query/spans/RepetitionSpans.java b/src/main/java/de/ids_mannheim/korap/query/spans/RepetitionSpans.java
index c4412d9..6019125 100644
--- a/src/main/java/de/ids_mannheim/korap/query/spans/RepetitionSpans.java
+++ b/src/main/java/de/ids_mannheim/korap/query/spans/RepetitionSpans.java
@@ -25,7 +25,7 @@
private int min,max;
private long matchCost;
- private List<CandidateSpans> matchList;
+ private List<CandidateSpan> matchList;
private Logger log = LoggerFactory.getLogger(RepetitionSpans.class);
// This advices the java compiler to ignore all loggings
public static final boolean DEBUG = false;
@@ -38,7 +38,7 @@
super(query, context, acceptDocs, termContexts);
this.min = query.getMin();
this.max = query.getMax();
- matchList = new ArrayList<CandidateSpans>();
+ matchList = new ArrayList<CandidateSpan>();
hasMoreSpans = firstSpans.next();
}
@@ -62,7 +62,7 @@
}
matchCost = 0;
- List<CandidateSpans> adjacentSpans = collectAdjacentSpans();
+ List<CandidateSpan> adjacentSpans = collectAdjacentSpans();
setMatchList(adjacentSpans);
}
return false;
@@ -71,14 +71,14 @@
/** Collect all adjacent spans occurring in a sequence.
* @return a list of the adjacent spans
* */
- private List<CandidateSpans> collectAdjacentSpans() throws IOException {
+ private List<CandidateSpan> collectAdjacentSpans() throws IOException {
- CandidateSpans startSpan = new CandidateSpans(firstSpans);
+ CandidateSpan startSpan = new CandidateSpan(firstSpans);
- List<CandidateSpans> adjacentSpans = new ArrayList<CandidateSpans>();
+ List<CandidateSpan> adjacentSpans = new ArrayList<CandidateSpan>();
adjacentSpans.add(startSpan);
- CandidateSpans prevSpan = startSpan;
+ CandidateSpan prevSpan = startSpan;
while ((hasMoreSpans = firstSpans.next()) &&
startSpan.getDoc() == firstSpans.doc() ){
@@ -87,7 +87,7 @@
break;
}
else if (firstSpans.start() == prevSpan.getEnd()){
- prevSpan = new CandidateSpans(firstSpans);
+ prevSpan = new CandidateSpan(firstSpans);
adjacentSpans.add(prevSpan);
}
}
@@ -97,8 +97,8 @@
/** Generate all possible repetition candidate spans from the adjacent spans
* and add them to the match list.
* */
- private void setMatchList(List<CandidateSpans> adjacentSpans){
- CandidateSpans startSpan, endSpan, matchSpan;
+ private void setMatchList(List<CandidateSpan> adjacentSpans){
+ CandidateSpan startSpan, endSpan, matchSpan;
for (int i=min; i<max+1; i++){
//System.out.println("num: "+i);
int j=0;
@@ -116,7 +116,7 @@
}
else {
endSpan = adjacentSpans.get(endIndex);
- matchSpan = new CandidateSpans(
+ matchSpan = new CandidateSpan(
startSpan.getStart(),
endSpan.getEnd(),
startSpan.getDoc(),
@@ -138,7 +138,7 @@
/** Add all the payloads of a candidate span
* */
private Collection<byte[]> computeMatchPayload(
- List<CandidateSpans> adjacentSpans, int start, int end) {
+ List<CandidateSpan> adjacentSpans, int start, int end) {
Collection<byte[]> payload = new ArrayList<byte[]>();
for (int i=start; i<= end; i++){
payload.addAll(adjacentSpans.get(i).getPayloads());
@@ -148,11 +148,11 @@
/** Add all the cost of a candidate span
* */
- private long computeMatchCost(List<CandidateSpans> adjacentSpans,
+ private long computeMatchCost(List<CandidateSpan> adjacentSpans,
int start, int end){
long matchCost = 0;
for (int i=start; i<= end; i++){
- CandidateSpans c = adjacentSpans.get(i);
+ CandidateSpan c = adjacentSpans.get(i);
matchCost += adjacentSpans.get(i).getCost();
}
return matchCost;
@@ -161,7 +161,7 @@
/** Setting match properties from the candidate span
* */
- private void setMatchProperties(CandidateSpans candidateSpan)
+ private void setMatchProperties(CandidateSpan candidateSpan)
throws IOException {
matchDocNumber = candidateSpan.getDoc();
matchStartPosition = candidateSpan.getStart();
diff --git a/src/main/java/de/ids_mannheim/korap/query/spans/TokenDistanceSpans.java b/src/main/java/de/ids_mannheim/korap/query/spans/TokenDistanceSpans.java
index 3b63d88..f3c4907 100644
--- a/src/main/java/de/ids_mannheim/korap/query/spans/TokenDistanceSpans.java
+++ b/src/main/java/de/ids_mannheim/korap/query/spans/TokenDistanceSpans.java
@@ -48,8 +48,8 @@
* from the candidate list prepared for the previous second spans.
* */
private void copyPossibleCandidates(){
- List<CandidateSpans> temp = new ArrayList<>();
- for (CandidateSpans cs : candidateList){
+ List<CandidateSpan> temp = new ArrayList<>();
+ for (CandidateSpan cs : candidateList){
if (cs.getEnd()+maxDistance > secondSpans.start())
temp.add(cs);
}
@@ -64,7 +64,7 @@
firstSpans.start() < secondSpans.end()){
if (firstSpans.end()+maxDistance > secondSpans.start())
- candidateList.add(new CandidateSpans(firstSpans));
+ candidateList.add(new CandidateSpan(firstSpans));
hasMoreFirstSpans = firstSpans.next();
}
@@ -72,7 +72,7 @@
@Override
protected boolean findMatch() throws IOException {
- CandidateSpans candidateSpan = candidateList.get(candidateListIndex);
+ CandidateSpan candidateSpan = candidateList.get(candidateListIndex);
if (minDistance == 0 &&
// intersection
candidateSpan.getStart() < secondSpans.end() &&
@@ -95,7 +95,7 @@
@Override
public long cost() {
- CandidateSpans candidateSpan = candidateList.get(candidateListIndex);
+ CandidateSpan candidateSpan = candidateList.get(candidateListIndex);
return candidateSpan.getCost() + secondSpans.cost();
}
diff --git a/src/main/java/de/ids_mannheim/korap/query/spans/UnorderedDistanceSpans.java b/src/main/java/de/ids_mannheim/korap/query/spans/UnorderedDistanceSpans.java
index 9d0aa65..7934f34 100644
--- a/src/main/java/de/ids_mannheim/korap/query/spans/UnorderedDistanceSpans.java
+++ b/src/main/java/de/ids_mannheim/korap/query/spans/UnorderedDistanceSpans.java
@@ -24,8 +24,8 @@
protected int minDistance, maxDistance;
protected boolean hasMoreFirstSpans, hasMoreSecondSpans;
- protected List<CandidateSpans> firstSpanList, secondSpanList;
- protected List<CandidateSpans> matchList;
+ protected List<CandidateSpan> firstSpanList, secondSpanList;
+ protected List<CandidateSpan> matchList;
private long matchCost;
private int matchListSpanNum;
protected int currentDocNum;
@@ -40,9 +40,9 @@
minDistance = query.getMinDistance();
maxDistance = query.getMaxDistance();
- firstSpanList = new ArrayList<CandidateSpans>();
- secondSpanList = new ArrayList<CandidateSpans>();
- matchList = new ArrayList<CandidateSpans>();
+ firstSpanList = new ArrayList<CandidateSpan>();
+ secondSpanList = new ArrayList<CandidateSpan>();
+ matchList = new ArrayList<CandidateSpan>();
hasMoreFirstSpans = firstSpans.next();
hasMoreSecondSpans = secondSpans.next();
@@ -90,7 +90,7 @@
// System.out.println(cs.getStart() +" "+ cs.getEnd());
// }
- CandidateSpans currentFirstSpan, currentSecondSpan;
+ CandidateSpan currentFirstSpan, currentSecondSpan;
if (!firstSpanList.isEmpty() && !secondSpanList.isEmpty()){
currentFirstSpan = firstSpanList.get(0) ;
@@ -140,7 +140,7 @@
}
}
- private boolean isLastCandidateSmaller(CandidateSpans currentFirstSpan, CandidateSpans
+ private boolean isLastCandidateSmaller(CandidateSpan currentFirstSpan, CandidateSpan
currentSecondSpan){
if (currentFirstSpan.getEnd() == currentSecondSpan.getEnd() ){
int secondEnd = secondSpanList.get(secondSpanList.size()-1).getEnd();
@@ -151,29 +151,29 @@
return false;
}
- protected abstract void updateList(List<CandidateSpans> candidateList);
+ protected abstract void updateList(List<CandidateSpan> candidateList);
/** Set the candidate list for the first element in the target list.
* @return true iff the spans enumeration still has a next element
* to be a candidate
*/
- protected abstract boolean setCandidateList(List<CandidateSpans>
+ protected abstract boolean setCandidateList(List<CandidateSpan>
candidateList, Spans candidate, boolean hasMoreCandidates,
- List<CandidateSpans> targetList) throws IOException;
+ List<CandidateSpan> targetList) throws IOException;
/** Search all matches between the target span and its candidates in the candidate
* list.
* @return the matches in a list
* */
- protected abstract List<CandidateSpans> findMatches(CandidateSpans target,
- List<CandidateSpans> candidateList);
+ protected abstract List<CandidateSpan> findMatches(CandidateSpan target,
+ List<CandidateSpan> candidateList);
/** Compute match properties and create a candidate span match
* to be added to the match list.
* @return a candidate span match
* */
- protected CandidateSpans createMatchCandidate(CandidateSpans target,
- CandidateSpans cs, boolean isDistanceZero) {
+ protected CandidateSpan createMatchCandidate(CandidateSpan target,
+ CandidateSpan cs, boolean isDistanceZero) {
int start = Math.min(target.getStart(), cs.getStart());
int end = Math.max(target.getEnd(),cs.getEnd());
@@ -190,7 +190,7 @@
}
}
- CandidateSpans match = new CandidateSpans(start,end,doc,cost,payloads);
+ CandidateSpan match = new CandidateSpan(start,end,doc,cost,payloads);
match.setChildSpan(cs);
return match;
}
@@ -198,7 +198,7 @@
/** Assign the first candidate span in the match list as the current span match.
* */
private void setMatchProperties() {
- CandidateSpans cs = matchList.get(0);
+ CandidateSpan cs = matchList.get(0);
matchDocNumber = cs.getDoc();
matchStartPosition = cs.getStart();
matchEndPosition = cs.getEnd();
diff --git a/src/main/java/de/ids_mannheim/korap/query/spans/UnorderedElementDistanceSpans.java b/src/main/java/de/ids_mannheim/korap/query/spans/UnorderedElementDistanceSpans.java
index 4a90575..a0c4474 100644
--- a/src/main/java/de/ids_mannheim/korap/query/spans/UnorderedElementDistanceSpans.java
+++ b/src/main/java/de/ids_mannheim/korap/query/spans/UnorderedElementDistanceSpans.java
@@ -29,7 +29,7 @@
// contains all previous elements whose position is greater than the last
// target span
- private List<CandidateSpans> elementList;
+ private List<CandidateSpan> elementList;
public UnorderedElementDistanceSpans(SpanDistanceQuery query,
AtomicReaderContext context, Bits acceptDocs,
@@ -39,7 +39,7 @@
getSpans(context, acceptDocs, termContexts);
hasMoreElements = elements.next();
elementPosition=0;
- elementList = new ArrayList<CandidateSpans>();
+ elementList = new ArrayList<CandidateSpan>();
}
@Override
@@ -74,13 +74,13 @@
return true;
}
- private boolean addSpan(Spans span, List<CandidateSpans> list, boolean hasMoreSpan)
+ private boolean addSpan(Spans span, List<CandidateSpan> list, boolean hasMoreSpan)
throws IOException {
int position;
while (hasMoreSpan && span.doc() == currentDocNum){
position = findElementPosition(span);
if (position != -1){
- list.add(new CandidateSpans(span,position));
+ list.add(new CandidateSpan(span,position));
hasMoreSpan = span.next();
return hasMoreSpan;
}
@@ -100,7 +100,7 @@
if (!elementList.isEmpty() &&
span.end() <= elementList.get(elementList.size()-1).getEnd()){
- for (CandidateSpans e : elementList)
+ for (CandidateSpan e : elementList)
if (e.getEnd() >= span.end() && e.getStart() <= span.start()){
return e.getPosition();
}
@@ -124,7 +124,7 @@
span.end() <= elements.end()){
return true;
}
- elementList.add(new CandidateSpans(elements,elementPosition));
+ elementList.add(new CandidateSpan(elements,elementPosition));
hasMoreElements = elements.next();
elementPosition++;
}
@@ -133,18 +133,18 @@
}
@Override
- protected boolean setCandidateList(List<CandidateSpans>
+ protected boolean setCandidateList(List<CandidateSpan>
candidateList, Spans candidate, boolean hasMoreCandidates,
- List<CandidateSpans> targetList) throws IOException {
+ List<CandidateSpan> targetList) throws IOException {
if (!targetList.isEmpty()){
- CandidateSpans cs;
- CandidateSpans target = targetList.get(0);
+ CandidateSpan cs;
+ CandidateSpan target = targetList.get(0);
int position;
while (hasMoreCandidates && candidate.doc() == target.getDoc()){
position = findElementPosition(candidate);
if (position != -1){
- cs = new CandidateSpans(candidate,position);
+ cs = new CandidateSpan(candidate,position);
if (isWithinMaxDistance(target, cs)){
candidateList.add(cs);
@@ -162,7 +162,7 @@
* @return true iff the target and candidate spans are within the maximum
* distance
* */
- protected boolean isWithinMaxDistance(CandidateSpans target, CandidateSpans candidate) {
+ protected boolean isWithinMaxDistance(CandidateSpan target, CandidateSpan candidate) {
int candidatePos = candidate.getPosition();
int targetPos = target.getPosition();
@@ -180,15 +180,15 @@
}
@Override
- protected List<CandidateSpans> findMatches(CandidateSpans target, List<CandidateSpans>
+ protected List<CandidateSpan> findMatches(CandidateSpan target, List<CandidateSpan>
candidateList) {
- List<CandidateSpans> matches = new ArrayList<>();
+ List<CandidateSpan> matches = new ArrayList<>();
int actualDistance;
int targetPos = target.getPosition();
- for (CandidateSpans cs : candidateList){
+ for (CandidateSpan cs : candidateList){
actualDistance = Math.abs( targetPos - cs.getPosition() );
if (minDistance == 0 && actualDistance == 0){
@@ -203,7 +203,7 @@
}
@Override
- protected void updateList(List<CandidateSpans> candidateList) {
+ protected void updateList(List<CandidateSpan> candidateList) {
updateElementList(candidateList.get(0).getPosition());
candidateList.remove(0);
}
@@ -213,8 +213,8 @@
* span.
* */
private void updateElementList(int position){
- Iterator<CandidateSpans> i = elementList.iterator();
- CandidateSpans e;
+ Iterator<CandidateSpan> i = elementList.iterator();
+ CandidateSpan e;
while(i.hasNext()){
e = i.next();
if (e.getPosition() <= position) {
diff --git a/src/main/java/de/ids_mannheim/korap/query/spans/UnorderedTokenDistanceSpans.java b/src/main/java/de/ids_mannheim/korap/query/spans/UnorderedTokenDistanceSpans.java
index 91ef11a..5f1abd9 100644
--- a/src/main/java/de/ids_mannheim/korap/query/spans/UnorderedTokenDistanceSpans.java
+++ b/src/main/java/de/ids_mannheim/korap/query/spans/UnorderedTokenDistanceSpans.java
@@ -33,8 +33,8 @@
if (firstSpanList.isEmpty() && secondSpanList.isEmpty()){
if (hasMoreFirstSpans && hasMoreSecondSpans &&
ensureSameDoc(firstSpans, secondSpans)){
- firstSpanList.add(new CandidateSpans(firstSpans));
- secondSpanList.add(new CandidateSpans(secondSpans));
+ firstSpanList.add(new CandidateSpan(firstSpans));
+ secondSpanList.add(new CandidateSpan(secondSpans));
currentDocNum = firstSpans.doc();
hasMoreFirstSpans = firstSpans.next();
hasMoreSecondSpans = secondSpans.next();
@@ -46,27 +46,27 @@
}
else if (firstSpanList.isEmpty() && hasMoreFirstSpans &&
firstSpans.doc() == currentDocNum){
- firstSpanList.add(new CandidateSpans(firstSpans));
+ firstSpanList.add(new CandidateSpan(firstSpans));
hasMoreFirstSpans = firstSpans.next();
}
else if (secondSpanList.isEmpty() && hasMoreSecondSpans &&
secondSpans.doc() == currentDocNum){
- secondSpanList.add(new CandidateSpans(secondSpans));
+ secondSpanList.add(new CandidateSpan(secondSpans));
hasMoreSecondSpans = secondSpans.next();
}
return true;
}
@Override
- protected boolean setCandidateList(List<CandidateSpans>
+ protected boolean setCandidateList(List<CandidateSpan>
candidateList, Spans candidate, boolean hasMoreCandidates,
- List<CandidateSpans> targetList) throws IOException {
+ List<CandidateSpan> targetList) throws IOException {
if (!targetList.isEmpty()){
- CandidateSpans target = targetList.get(0);
+ CandidateSpan target = targetList.get(0);
while (hasMoreCandidates && candidate.doc() == target.getDoc()
&& isWithinMaxDistance(target,candidate)){
- candidateList.add(new CandidateSpans(candidate));
+ candidateList.add(new CandidateSpan(candidate));
hasMoreCandidates = candidate.next();
}
}
@@ -77,7 +77,7 @@
* @return true iff the target and candidate spans are within the maximum
* distance
* */
- protected boolean isWithinMaxDistance(CandidateSpans target, Spans candidate) {
+ protected boolean isWithinMaxDistance(CandidateSpan target, Spans candidate) {
// left candidate
if (candidate.end() < target.getStart() &&
candidate.end() + maxDistance <= target.getStart()){
@@ -92,12 +92,12 @@
}
@Override
- protected List<CandidateSpans> findMatches(CandidateSpans target, List<CandidateSpans>
+ protected List<CandidateSpan> findMatches(CandidateSpan target, List<CandidateSpan>
candidateList) {
- List<CandidateSpans> matches = new ArrayList<>();
+ List<CandidateSpan> matches = new ArrayList<>();
int actualDistance;
- for (CandidateSpans cs : candidateList){
+ for (CandidateSpan cs : candidateList){
if (minDistance == 0 &&
//intersection
target.getStart() < cs.getEnd() &&
@@ -119,7 +119,7 @@
}
@Override
- protected void updateList(List<CandidateSpans> candidateList) {
+ protected void updateList(List<CandidateSpan> candidateList) {
candidateList.remove(0);
}