Example usage for com.google.common.collect Range greaterThan

List of usage examples for com.google.common.collect Range greaterThan

  1. HOME
  2. Java
  3. com.google.common
  4. com.google.common.collect.*
  5. Range
  6. greaterThan

Introduction

In this page you can find the example usage for com.google.common.collect Range greaterThan.

Prototype

public static <C extends Comparable<?>> Range<C> greaterThan(C endpoint)

Source Link

Document

Returns a range that contains all values strictly greater than endpoint .

Usage

From source file:com.stackframe.base.Numbers.java

private static Set<Number> positiveIntegers() {
    // Consider adding BigInteger and other subclasses of Number that are integers.
    Set<? extends Number> longKeys = ContiguousSet.create(Range.greaterThan(0L), DiscreteDomain.longs());
    Set<? extends Number> intKeys = ContiguousSet.create(Range.greaterThan(0), DiscreteDomain.integers());
    return Sets.union(longKeys, intKeys);
}

From source file:com.cinchapi.concourse.server.concurrent.RangeTokens.java

/**
 * Convert the specified range {@code token} to one or more {@link Range
 * ranges} that provide the appropriate coverage.
 * // w ww  .j a  v a 2s. com
 * @param token
 * @return the Ranges
 */
public static Iterable<Range<Value>> convertToRange(RangeToken token) {
    List<Range<Value>> ranges = Lists.newArrayListWithCapacity(1);
    if (token.getOperator() == Operator.EQUALS || token.getOperator() == null) { // null operator means
                                                                                 // the range token is for
                                                                                 // writing
        ranges.add(Range.singleton(token.getValues()[0]));
    } else if (token.getOperator() == Operator.NOT_EQUALS) {
        ranges.add(Range.lessThan(token.getValues()[0]));
        ranges.add(Range.greaterThan(token.getValues()[0]));
    } else if (token.getOperator() == Operator.GREATER_THAN) {
        ranges.add(Range.greaterThan(token.getValues()[0]));
    } else if (token.getOperator() == Operator.GREATER_THAN_OR_EQUALS) {
        ranges.add(Range.atLeast(token.getValues()[0]));
    } else if (token.getOperator() == Operator.LESS_THAN) {
        ranges.add(Range.lessThan(token.getValues()[0]));
    } else if (token.getOperator() == Operator.LESS_THAN_OR_EQUALS) {
        ranges.add(Range.atMost(token.getValues()[0]));
    } else if (token.getOperator() == Operator.BETWEEN) {
        Value a = token.getValues()[0];
        Value b = token.getValues()[1];
        if (a == Value.NEGATIVE_INFINITY && b == Value.POSITIVE_INFINITY) {
            ranges.add(Range.<Value>all());
        } else if (token.getValues().length == 3) {
            ranges.add(Range.open(a, b));
        } else if (token.getValues().length == 4) {
            ranges.add(Range.closed(a, b));
        } else if (token.getValues().length == 5) {
            ranges.add(Range.openClosed(a, b));
        } else {
            ranges.add(Range.closedOpen(a, b));
        }
    } else if (token.getOperator() == Operator.REGEX || token.getOperator() == Operator.NOT_REGEX) {
        ranges.add(Range.<Value>all());
    } else {
        throw new UnsupportedOperationException();
    }
    return ranges;
}

From source file:org.apache.druid.sql.calcite.filtration.Bounds.java

public static Range<BoundValue> toRange(final BoundDimFilter bound) {
    final BoundValue upper = bound.getUpper() != null ? new BoundValue(bound.getUpper(), bound.getOrdering())
            : null;//from w ww . j  a v  a  2s.c  om
    final BoundValue lower = bound.getLower() != null ? new BoundValue(bound.getLower(), bound.getOrdering())
            : null;

    if (lower == null) {
        return bound.isUpperStrict() ? Range.lessThan(upper) : Range.atMost(upper);
    } else if (upper == null) {
        return bound.isLowerStrict() ? Range.greaterThan(lower) : Range.atLeast(lower);
    } else {
        return Range.range(lower, bound.isLowerStrict() ? BoundType.OPEN : BoundType.CLOSED, upper,
                bound.isUpperStrict() ? BoundType.OPEN : BoundType.CLOSED);
    }
}

From source file:de.visiom.carpc.asb.serviceregistry.impl.entities.adapters.RangeAdapter.java

@Override
public Range<BigDecimal> unmarshal(String v) throws Exception {
    boolean leftInfinity = false, rightInfinity = false;
    String firstNumberString = v.substring(0, v.indexOf(".."));
    String secondNumberString = v.substring(v.indexOf("..") + 2);
    BigDecimal firstNumber = null, secondNumber = null;
    if (firstNumberString.equals("infty")) {
        leftInfinity = true;//  w ww . j a v  a2  s . co  m
    } else {
        firstNumber = BigDecimal.valueOf(Double.parseDouble(firstNumberString));
    }
    if (secondNumberString.equals("infty")) {
        rightInfinity = true;
    } else {
        secondNumber = BigDecimal.valueOf(Double.parseDouble(secondNumberString));
    }
    Range<BigDecimal> result = null;
    if (!leftInfinity && !rightInfinity) {
        result = Range.open(firstNumber, secondNumber);
    } else if (leftInfinity && rightInfinity) {
        result = Range.all();
    } else if (leftInfinity && !rightInfinity) {
        result = Range.lessThan(secondNumber);
    } else {
        result = Range.greaterThan(firstNumber);
    }
    return result;
}

From source file:org.apache.kylin.storage.cache.TsConditionExtractor.java

private static Range<Long> extractTsConditionInternal(TupleFilter filter, TblColRef colRef) {
    if (filter == null) {
        return Range.all();
    }//from  w w w  .ja va  2 s.  c o  m

    if (filter instanceof LogicalTupleFilter) {
        if (filter.getOperator() == TupleFilter.FilterOperatorEnum.AND) {
            Range<Long> ret = Range.all();
            for (TupleFilter child : filter.getChildren()) {
                Range childRange = extractTsConditionInternal(child, colRef);
                if (childRange != null) {
                    if (ret.isConnected(childRange) && !ret.intersection(childRange).isEmpty()) {
                        ret = ret.intersection(childRange);
                    } else {
                        return null;
                    }
                } else {
                    return null;
                }
            }
            return ret.isEmpty() ? null : ret;
        } else {
            //for conditions like date > DATE'2000-11-11' OR date < DATE '1999-01-01'
            //we will use Ranges.all() rather than two ranges to represent them
            return Range.all();
        }
    }

    if (filter instanceof CompareTupleFilter) {
        CompareTupleFilter compareTupleFilter = (CompareTupleFilter) filter;
        if (compareTupleFilter.getColumn() == null)// column will be null at filters like " 1<>1"
            return Range.all();

        if (compareTupleFilter.getColumn().equals(colRef)) {
            Object firstValue = compareTupleFilter.getFirstValue();
            long t;
            switch (compareTupleFilter.getOperator()) {
            case EQ:
                t = DateFormat.stringToMillis((String) firstValue);
                return Range.closed(t, t);
            case LT:
                t = DateFormat.stringToMillis((String) firstValue);
                return Range.lessThan(t);
            case LTE:
                t = DateFormat.stringToMillis((String) firstValue);
                return Range.atMost(t);
            case GT:
                t = DateFormat.stringToMillis((String) firstValue);
                return Range.greaterThan(t);
            case GTE:
                t = DateFormat.stringToMillis((String) firstValue);
                return Range.atLeast(t);
            case NEQ:
            case IN://not handled for now
                break;
            default:
            }
        }
    }
    return Range.all();
}

From source file:org.jpmml.evaluator.DiscretizationUtil.java

static public Range<Double> toRange(Interval interval) {
    Double leftMargin = interval.getLeftMargin();
    Double rightMargin = interval.getRightMargin();

    // "The attributes leftMargin and rightMargin are optional but at least one value must be defined"
    if (leftMargin == null && rightMargin == null) {
        throw new InvalidFeatureException(interval);
    } // End if//www .  j  a  v  a2  s .  com

    if (leftMargin != null && rightMargin != null && (leftMargin).compareTo(rightMargin) > 0) {
        throw new InvalidFeatureException(interval);
    }

    Interval.Closure closure = interval.getClosure();
    switch (closure) {
    case OPEN_OPEN: {
        if (leftMargin == null) {
            return Range.lessThan(rightMargin);
        } else

        if (rightMargin == null) {
            return Range.greaterThan(leftMargin);
        }

        return Range.open(leftMargin, rightMargin);
    }
    case OPEN_CLOSED: {
        if (leftMargin == null) {
            return Range.atMost(rightMargin);
        } else

        if (rightMargin == null) {
            return Range.greaterThan(leftMargin);
        }

        return Range.openClosed(leftMargin, rightMargin);
    }
    case CLOSED_OPEN: {
        if (leftMargin == null) {
            return Range.lessThan(rightMargin);
        } else

        if (rightMargin == null) {
            return Range.atLeast(leftMargin);
        }

        return Range.closedOpen(leftMargin, rightMargin);
    }
    case CLOSED_CLOSED: {
        if (leftMargin == null) {
            return Range.atMost(rightMargin);
        } else

        if (rightMargin == null) {
            return Range.atLeast(leftMargin);
        }

        return Range.closed(leftMargin, rightMargin);
    }
    default:
        throw new UnsupportedFeatureException(interval, closure);
    }
}

From source file:dollar.api.types.DollarRange.java

public DollarRange(boolean lowerBounds, boolean upperBounds, boolean closedLeft, boolean closedRight,
        @Nullable Value lower, @Nullable Value upper) {
    super();//  w  w w. j av  a  2 s  .com
    Value lowerBound;
    Value upperBound;
    if ((lower != null) && (upper != null) && (lower.compareTo(upper) > 0)) {
        lowerBound = upper;
        upperBound = lower;
        reversed = true;
    } else {
        lowerBound = lower;
        upperBound = upper;
    }
    if (!lowerBounds && !upperBounds) {
        range = Range.all();
    } else if (!lowerBounds) {
        if (closedRight) {
            range = Range.atMost(upperBound);
        } else {
            range = Range.lessThan(upperBound);
        }
    } else if (!upperBounds) {
        if (closedLeft) {
            range = Range.atLeast(lowerBound);
        } else {
            range = Range.greaterThan(lowerBound);
        }
    } else if (closedLeft) {
        if (closedRight) {
            range = Range.closed(lowerBound, upperBound);
        } else {
            //openRight
            range = Range.closedOpen(lowerBound, upperBound);
        }
    } else if (!closedLeft) {
        //openLeft
        if (closedRight) {
            range = Range.openClosed(lowerBound, upperBound);
        } else {
            //openRight
            if (lowerBound.equals(upperBound)) {
                throw new IllegalArgumentException(
                        "Cannot have an open range with lower bounds being the same as upper " + "bounds");
            } else {
                range = Range.open(lowerBound, upperBound);
            }
        }
    } else {
        throw new IllegalStateException();
    }
}

From source file:com.wealdtech.jackson.modules.DateTimeRangeDeserializer.java

public static Range<DateTime> deserialize(final String txt) throws IOException {
      final int txtLen = txt.length();

      final int firstDateChar;
      boolean lowerClosed;
      if (txt.charAt(0) == '[') {
          firstDateChar = 1;//from   www.ja  va 2 s. co m
          lowerClosed = true;
      } else if (txt.charAt(0) == '(') {
          firstDateChar = 1;
          lowerClosed = false;
      } else if (txt.charAt(0) >= '0' && txt.charAt(0) <= '9') {
          // Lazy version
          firstDateChar = 0;
          lowerClosed = true;
      } else {
          throw new DataError.Bad("Unexpected first character in range \"" + txt + "\"");
      }

      boolean upperClosed;
      if (txt.charAt(txtLen - 1) == ']') {
          upperClosed = true;
      } else if (txt.charAt(txtLen - 1) == ')') {
          upperClosed = false;
      } else if (firstDateChar == 0) {
          upperClosed = false;
      } else {
          throw new DataError.Bad("Unexpected last character in range \"" + txt + "\"");
      }

      final Iterator<String> dateTimes;
      if (txt.indexOf(WEALD_SPLITTER_CHAR) != -1) {
          dateTimes = WEALD_SPLITTER.split(txt.substring(firstDateChar, txtLen - firstDateChar)).iterator();
      } else if (txt.indexOf(GUAVA_SPLITTER_CHAR) != -1) {
          dateTimes = GUAVA_SPLITTER.split(txt.substring(firstDateChar, txtLen - firstDateChar)).iterator();
      } else {
          throw new DataError.Bad("Cannot find a range separator in range \"" + txt + "\"");
      }
      String start = dateTimes.next();
      String end = dateTimes.next();

      boolean lowerBound;
      final DateTime lowerPoint;
      if (start.equals(NEGATIVE_INFINITY)) {
          lowerBound = false;
          lowerPoint = null;
      } else {
          lowerBound = true;
          lowerPoint = DateTimeDeserializer.deserialize(start);
      }

      boolean upperBound;
      final DateTime upperPoint;
      if (end.equals(POSITIVE_INFINITY)) {
          upperBound = false;
          upperPoint = null;
      } else {
          upperBound = true;
          upperPoint = DateTimeDeserializer.deserialize(end);
      }

      if (lowerBound == false && upperBound == false) {
          return Range.all();
      } else if (lowerBound == false) {
          // Upper present
          if (upperClosed == true) {
              return Range.lessThan(upperPoint);
          } else {
              return Range.atMost(upperPoint);
          }
      } else if (upperBound == false) {
          // Lower present
          if (lowerClosed == true) {
              return Range.atLeast(lowerPoint);
          } else {
              return Range.greaterThan(lowerPoint);
          }
      } else {
          // Both present
          if (lowerClosed == true) {
              if (upperClosed == true) {
                  return Range.closed(lowerPoint, upperPoint);
              } else {
                  return Range.closedOpen(lowerPoint, upperPoint);
              }
          } else {
              if (upperClosed == true) {
                  return Range.openClosed(lowerPoint, upperPoint);
              } else {
                  return Range.open(lowerPoint, upperPoint);
              }
          }
      }
  }

From source file:com.pingcap.tikv.predicates.RangeBuilder.java

/**
 * Turn CNF filters into range//from  ww  w  .java2 s. c  o m
 *
 * @param accessConditions filters in CNF list
 * @param type index column type
 * @return access ranges
 */
@SuppressWarnings("unchecked")
static List<Range> exprToRanges(List<TiExpr> accessConditions, DataType type) {
    if (accessConditions == null || accessConditions.size() == 0) {
        return ImmutableList.of();
    }
    RangeSet ranges = TreeRangeSet.create();
    ranges.add(Range.all());
    for (TiExpr ac : accessConditions) {
        NormalizedCondition cond = AccessConditionNormalizer.normalize(ac);
        TiConstant constVal = cond.constantVals.get(0);
        Comparable<?> comparableVal = Comparables.wrap(constVal.getValue());
        TiExpr expr = cond.condition;

        if (expr instanceof GreaterThan) {
            ranges = ranges.subRangeSet(Range.greaterThan(comparableVal));
        } else if (expr instanceof GreaterEqual) {
            ranges = ranges.subRangeSet(Range.atLeast(comparableVal));
        } else if (expr instanceof LessThan) {
            ranges = ranges.subRangeSet(Range.lessThan(comparableVal));
        } else if (expr instanceof LessEqual) {
            ranges = ranges.subRangeSet(Range.atMost(comparableVal));
        } else if (expr instanceof Equal) {
            ranges = ranges.subRangeSet(Range.singleton(comparableVal));
        } else if (expr instanceof NotEqual) {
            RangeSet left = ranges.subRangeSet(Range.lessThan(comparableVal));
            RangeSet right = ranges.subRangeSet(Range.greaterThan(comparableVal));
            ranges = TreeRangeSet.create(left);
            ranges.addAll(right);
        } else {
            throw new TiClientInternalException(
                    "Unsupported conversion to Range " + expr.getClass().getSimpleName());
        }
    }
    return ImmutableList.copyOf(ranges.asRanges());
}

From source file:org.apache.kylin.common.util.RangeUtil.java

/**
 * remove from self the elements that exist in other
 * @return/*from   w  w  w . jav a  2 s. c  o  m*/
 */
public static <C extends Comparable<?>> List<Range<C>> remove(Range<C> self, Range<C> other) {

    // mimic the following logic in guava 18:
    //        RangeSet<C> rangeSet = TreeRangeSet.create();
    //        rangeSet.add(self);
    //        rangeSet.remove(other);
    //        return Lists.newArrayList(rangeSet.asRanges());

    if (other == null || !self.isConnected(other)) {
        return Collections.singletonList(self);
    }

    Range<C> share = self.intersection(other);
    if (share.isEmpty()) {
        return Collections.singletonList(self);
    }

    List<Range<C>> ret = Lists.newArrayList();

    //see left part
    if (!self.hasLowerBound()) {
        if (share.hasLowerBound()) {
            if (share.lowerBoundType() == BoundType.CLOSED) {
                ret.add(Range.lessThan(share.lowerEndpoint()));
            } else {
                ret.add(Range.atMost(share.lowerEndpoint()));
            }
        }
    } else {
        if (self.lowerEndpoint() != share.lowerEndpoint()) {
            if (self.lowerBoundType() == BoundType.CLOSED) {
                if (share.lowerBoundType() == BoundType.CLOSED) {
                    ret.add(Range.closedOpen(self.lowerEndpoint(), share.lowerEndpoint()));
                } else {
                    ret.add(Range.closed(self.lowerEndpoint(), share.lowerEndpoint()));
                }
            } else {
                if (share.lowerBoundType() == BoundType.CLOSED) {
                    ret.add(Range.open(self.lowerEndpoint(), share.lowerEndpoint()));
                } else {
                    ret.add(Range.openClosed(self.lowerEndpoint(), share.lowerEndpoint()));
                }
            }
        } else {
            if (self.lowerBoundType() == BoundType.CLOSED && share.lowerBoundType() == BoundType.OPEN) {
                ret.add(Range.closed(self.lowerEndpoint(), share.lowerEndpoint()));
            }
        }
    }

    //see right part 
    if (!self.hasUpperBound()) {
        if (share.hasUpperBound()) {
            if (share.upperBoundType() == BoundType.CLOSED) {
                ret.add(Range.greaterThan(share.upperEndpoint()));
            } else {
                ret.add(Range.atLeast(share.upperEndpoint()));
            }
        }
    } else {
        if (self.upperEndpoint() != share.upperEndpoint()) {
            if (self.upperBoundType() == BoundType.CLOSED) {
                if (share.upperBoundType() == BoundType.CLOSED) {
                    ret.add(Range.openClosed(share.upperEndpoint(), self.upperEndpoint()));
                } else {
                    ret.add(Range.closed(share.upperEndpoint(), self.upperEndpoint()));
                }
            } else {
                if (share.upperBoundType() == BoundType.CLOSED) {
                    ret.add(Range.open(share.upperEndpoint(), self.upperEndpoint()));
                } else {
                    ret.add(Range.closedOpen(share.upperEndpoint(), self.upperEndpoint()));
                }
            }
        } else {
            if (self.upperBoundType() == BoundType.CLOSED && share.upperBoundType() == BoundType.OPEN) {
                ret.add(Range.closed(self.upperEndpoint(), share.upperEndpoint()));
            }
        }
    }

    return ret;

}