Example #1
0
 private long aggregateForEntries(Aggregate aggr) {
   AvlNode<E> root = rootReference.get();
   long total = aggr.treeAggregate(root);
   if (range.hasLowerBound()) {
     total -= aggregateBelowRange(aggr, root);
   }
   if (range.hasUpperBound()) {
     total -= aggregateAboveRange(aggr, root);
   }
   return total;
 }
Example #2
0
  /**
   * Returns the intersection of the two ranges, or an empty range if their intersection is empty.
   */
  GeneralRange<T> intersect(GeneralRange<T> other) {
    checkNotNull(other);
    checkArgument(comparator.equals(other.comparator));

    boolean hasLowBound = this.hasLowerBound;
    @Nullable T lowEnd = getLowerEndpoint();
    BoundType lowType = getLowerBoundType();
    if (!hasLowerBound()) {
      hasLowBound = other.hasLowerBound;
      lowEnd = other.getLowerEndpoint();
      lowType = other.getLowerBoundType();
    } else if (other.hasLowerBound()) {
      int cmp = comparator.compare(getLowerEndpoint(), other.getLowerEndpoint());
      if (cmp < 0 || (cmp == 0 && other.getLowerBoundType() == OPEN)) {
        lowEnd = other.getLowerEndpoint();
        lowType = other.getLowerBoundType();
      }
    }

    boolean hasUpBound = this.hasUpperBound;
    @Nullable T upEnd = getUpperEndpoint();
    BoundType upType = getUpperBoundType();
    if (!hasUpperBound()) {
      hasUpBound = other.hasUpperBound;
      upEnd = other.getUpperEndpoint();
      upType = other.getUpperBoundType();
    } else if (other.hasUpperBound()) {
      int cmp = comparator.compare(getUpperEndpoint(), other.getUpperEndpoint());
      if (cmp > 0 || (cmp == 0 && other.getUpperBoundType() == OPEN)) {
        upEnd = other.getUpperEndpoint();
        upType = other.getUpperBoundType();
      }
    }

    if (hasLowBound && hasUpBound) {
      int cmp = comparator.compare(lowEnd, upEnd);
      if (cmp > 0 || (cmp == 0 && lowType == OPEN && upType == OPEN)) {
        // force allowed empty range
        lowEnd = upEnd;
        lowType = OPEN;
        upType = CLOSED;
      }
    }

    return new GeneralRange<T>(comparator, hasLowBound, lowEnd, lowType, hasUpBound, upEnd, upType);
  }
Example #3
0
 @Nullable
 private AvlNode<E> lastNode() {
   AvlNode<E> root = rootReference.get();
   if (root == null) {
     return null;
   }
   AvlNode<E> node;
   if (range.hasUpperBound()) {
     E endpoint = range.getUpperEndpoint();
     node = rootReference.get().floor(comparator(), endpoint);
     if (node == null) {
       return null;
     }
     if (range.getUpperBoundType() == BoundType.OPEN
         && comparator().compare(endpoint, node.getElement()) == 0) {
       node = node.pred;
     }
   } else {
     node = header.pred;
   }
   return (node == header || !range.contains(node.getElement())) ? null : node;
 }