Example #1
0
 private static Set<Range> intersectionOneWrapping(Range wrapping, Range other) {
   Set<Range> intersection = new HashSet<Range>(2);
   if (other.contains(wrapping.right)) intersection.add(new Range(other.left, wrapping.right));
   // need the extra compareto here because ranges are asymmetrical; wrapping.left _is not_
   // contained by the wrapping range
   if (other.contains(wrapping.left) && wrapping.left.compareTo(other.right) < 0)
     intersection.add(new Range(wrapping.left, other.right));
   return Collections.unmodifiableSet(intersection);
 }
Example #2
0
  public static boolean isTokenInRanges(Token token, Iterable<Range> ranges) {
    assert ranges != null;

    for (Range range : ranges) {
      if (range.contains(token)) {
        return true;
      }
    }
    return false;
  }
Example #3
0
  /**
   * @param that
   * @return the intersection of the two Ranges. this can be two disjoint Ranges if one is wrapping
   *     and one is not. say you have nodes G and M, with query range (D,T]; the intersection is
   *     (M-T] and (D-G]. If there is no intersection, an empty list is returned.
   */
  public Set<Range> intersectionWith(Range that) {
    if (that.contains(this)) return rangeSet(this);
    if (this.contains(that)) return rangeSet(that);

    boolean thiswraps = isWrapAround(left, right);
    boolean thatwraps = isWrapAround(that.left, that.right);
    if (!thiswraps && !thatwraps) {
      // neither wraps.  the straightforward case.
      if (!(left.compareTo(that.right) < 0 && that.left.compareTo(right) < 0))
        return Collections.emptySet();
      return rangeSet(
          new Range(
              (Token) ObjectUtils.max(this.left, that.left),
              (Token) ObjectUtils.min(this.right, that.right)));
    }
    if (thiswraps && thatwraps) {
      // if the starts are the same, one contains the other, which we have already ruled out.
      assert !this.left.equals(that.left);
      // two wrapping ranges always intersect.
      // since we have already determined that neither this nor that contains the other, we have 2
      // cases,
      // and mirror images of those case.
      // (1) both of that's (1, 2] endpoints lie in this's (A, B] right segment:
      //  ---------B--------A--1----2------>
      // (2) only that's start endpoint lies in this's right segment:
      //  ---------B----1---A-------2------>
      // or, we have the same cases on the left segement, which we can handle by swapping this and
      // that.
      return this.left.compareTo(that.left) < 0
          ? intersectionBothWrapping(this, that)
          : intersectionBothWrapping(that, this);
    }
    if (thiswraps && !thatwraps) return intersectionOneWrapping(this, that);
    assert (!thiswraps && thatwraps);
    return intersectionOneWrapping(that, this);
  }