List of usage examples for com.google.common.collect Range greaterThan
public static <C extends Comparable<?>> Range<C> greaterThan(C endpoint)
From source file:com.palantir.atlasdb.keyvalue.cassandra.TokenAwareMapper.java
public void refresh() { List<TokenRange> tokenRanges = getTokenRanges(); ImmutableRangeMap.Builder<Token, List<InetAddress>> newTokenRing = ImmutableRangeMap.builder(); for (TokenRange tokenRange : tokenRanges) { List<InetAddress> hosts = Lists.transform(tokenRange.getEndpoints(), new Function<String, InetAddress>() { @Override/*w w w . j av a 2 s. com*/ public InetAddress apply(String endpoint) { try { return InetAddress.getByName(endpoint); } catch (UnknownHostException e) { throw new RuntimeException(e); } } }); Token startToken = new Token(BaseEncoding.base16().decode(tokenRange.getStart_token().toUpperCase())); Token endToken = new Token(BaseEncoding.base16().decode(tokenRange.getEnd_token().toUpperCase())); if (startToken.compareTo(endToken) <= 0) { newTokenRing.put(Range.openClosed(startToken, endToken), hosts); } else { // Handle wrap-around newTokenRing.put(Range.greaterThan(startToken), hosts); newTokenRing.put(Range.atMost(endToken), hosts); } } tokenRing.set(newTokenRing.build()); }
From source file:org.apache.calcite.adapter.druid.DruidDateTimeUtils.java
protected static List<Range<Calendar>> leafToRanges(RexCall call, boolean withNot) { switch (call.getKind()) { case EQUALS://from w ww. java 2 s . c om case LESS_THAN: case LESS_THAN_OR_EQUAL: case GREATER_THAN: case GREATER_THAN_OR_EQUAL: { final Calendar value; if (call.getOperands().get(0) instanceof RexInputRef && literalValue(call.getOperands().get(1)) != null) { value = literalValue(call.getOperands().get(1)); } else if (call.getOperands().get(1) instanceof RexInputRef && literalValue(call.getOperands().get(0)) != null) { value = literalValue(call.getOperands().get(0)); } else { return null; } switch (call.getKind()) { case LESS_THAN: return ImmutableList.of(withNot ? Range.atLeast(value) : Range.lessThan(value)); case LESS_THAN_OR_EQUAL: return ImmutableList.of(withNot ? Range.greaterThan(value) : Range.atMost(value)); case GREATER_THAN: return ImmutableList.of(withNot ? Range.atMost(value) : Range.greaterThan(value)); case GREATER_THAN_OR_EQUAL: return ImmutableList.of(withNot ? Range.lessThan(value) : Range.atLeast(value)); default: if (!withNot) { return ImmutableList.of(Range.closed(value, value)); } return ImmutableList.of(Range.lessThan(value), Range.greaterThan(value)); } } case BETWEEN: { final Calendar value1; final Calendar value2; if (literalValue(call.getOperands().get(2)) != null && literalValue(call.getOperands().get(3)) != null) { value1 = literalValue(call.getOperands().get(2)); value2 = literalValue(call.getOperands().get(3)); } else { return null; } boolean inverted = value1.compareTo(value2) > 0; if (!withNot) { return ImmutableList.of(inverted ? Range.closed(value2, value1) : Range.closed(value1, value2)); } return ImmutableList.of(Range.lessThan(inverted ? value2 : value1), Range.greaterThan(inverted ? value1 : value2)); } case IN: { ImmutableList.Builder<Range<Calendar>> ranges = ImmutableList.builder(); for (RexNode operand : Util.skip(call.operands)) { final Calendar element = literalValue(operand); if (element == null) { return null; } if (withNot) { ranges.add(Range.lessThan(element)); ranges.add(Range.greaterThan(element)); } else { ranges.add(Range.closed(element, element)); } } return ranges.build(); } default: return null; } }
From source file:org.raml.yagi.framework.grammar.BaseGrammar.java
/** * Matches any number greater than zero * @return The rule */ public Rule positiveNumberType() { return new NumberTypeRule(Range.greaterThan(0D)); }
From source file:org.apache.hadoop.hive.ql.optimizer.calcite.druid.DruidIntervalUtils.java
protected static List<Range> leafToRanges(RelDataType type, RexCall call, boolean withNot) { switch (call.getKind()) { case EQUALS:// w ww. j a va2s .c om case LESS_THAN: case LESS_THAN_OR_EQUAL: case GREATER_THAN: case GREATER_THAN_OR_EQUAL: { RexLiteral literal = null; if (call.getOperands().get(0) instanceof RexInputRef && call.getOperands().get(1) instanceof RexLiteral) { literal = extractLiteral(call.getOperands().get(1)); } else if (call.getOperands().get(0) instanceof RexInputRef && call.getOperands().get(1).getKind() == SqlKind.CAST) { literal = extractLiteral(call.getOperands().get(1)); } else if (call.getOperands().get(1) instanceof RexInputRef && call.getOperands().get(0) instanceof RexLiteral) { literal = extractLiteral(call.getOperands().get(0)); } else if (call.getOperands().get(1) instanceof RexInputRef && call.getOperands().get(0).getKind() == SqlKind.CAST) { literal = extractLiteral(call.getOperands().get(0)); } if (literal == null) { return null; } Comparable value = literalToType(literal, type); if (value == null) { return null; } if (call.getKind() == SqlKind.LESS_THAN) { return Arrays.<Range>asList(withNot ? Range.atLeast(value) : Range.lessThan(value)); } else if (call.getKind() == SqlKind.LESS_THAN_OR_EQUAL) { return Arrays.<Range>asList(withNot ? Range.greaterThan(value) : Range.atMost(value)); } else if (call.getKind() == SqlKind.GREATER_THAN) { return Arrays.<Range>asList(withNot ? Range.atMost(value) : Range.greaterThan(value)); } else if (call.getKind() == SqlKind.GREATER_THAN_OR_EQUAL) { return Arrays.<Range>asList(withNot ? Range.lessThan(value) : Range.atLeast(value)); } else { //EQUALS if (!withNot) { return Arrays.<Range>asList(Range.closed(value, value)); } return Arrays.<Range>asList(Range.lessThan(value), Range.greaterThan(value)); } } case BETWEEN: { RexLiteral literal1 = extractLiteral(call.getOperands().get(2)); if (literal1 == null) { return null; } RexLiteral literal2 = extractLiteral(call.getOperands().get(3)); if (literal2 == null) { return null; } Comparable value1 = literalToType(literal1, type); Comparable value2 = literalToType(literal2, type); if (value1 == null || value2 == null) { return null; } boolean inverted = value1.compareTo(value2) > 0; if (!withNot) { return Arrays.<Range>asList(inverted ? Range.closed(value2, value1) : Range.closed(value1, value2)); } return Arrays.<Range>asList(Range.lessThan(inverted ? value2 : value1), Range.greaterThan(inverted ? value1 : value2)); } case IN: { List<Range> ranges = Lists.newArrayList(); for (int i = 1; i < call.getOperands().size(); i++) { RexLiteral literal = extractLiteral(call.getOperands().get(i)); if (literal == null) { return null; } Comparable element = literalToType(literal, type); if (element == null) { return null; } if (withNot) { ranges.addAll(Arrays.<Range>asList(Range.lessThan(element), Range.greaterThan(element))); } else { ranges.add(Range.closed(element, element)); } } return ranges; } default: return null; } }
From source file:cn.ict.zyq.bestConf.COMT2.COMT2.java
private ArrayList<Branch2> getLeavesInfoForM5P(M5P model) { ArrayList<Branch2> retval = new ArrayList<Branch2>(); ArrayList<RuleNode> leafNodes = new ArrayList<RuleNode>(); model.getM5RootNode().returnLeaves(new ArrayList[] { leafNodes }); for (RuleNode leaf : leafNodes) { Branch2 branch = new Branch2(); ArrayList<PreConstructedLinearModel> lmodel = new ArrayList<PreConstructedLinearModel>(); lmodel.add(leaf.getModel());// www . ja v a 2s . co m branch.setLinearModels(lmodel); Map<Attribute, Range<Double>> rangeMap = branch.getRangeMap(); RuleNode parent = leaf, child; while (parent.parentNode() != null) { child = parent; parent = parent.parentNode(); Attribute att = this.labeledInstances.attribute(parent.splitAtt()); Range<Double> previous = null; if (parent.leftNode() == child) previous = rangeMap.put(att, Range.atMost(parent.splitVal())); else previous = rangeMap.put(att, Range.greaterThan(parent.splitVal())); //the attribute is visited previously if (previous != null) { previous = rangeMap.get(att).intersection(previous); rangeMap.put(att, previous); } } retval.add(branch); } return retval; }
From source file:org.apache.druid.query.filter.BoundDimFilter.java
@Override public RangeSet<String> getDimensionRangeSet(String dimension) { if (!(Objects.equals(getDimension(), dimension) && getExtractionFn() == null && ordering.equals(StringComparators.LEXICOGRAPHIC))) { return null; }/*from ww w .j ava 2s .c om*/ RangeSet<String> retSet = TreeRangeSet.create(); Range<String> range; if (getLower() == null) { range = isUpperStrict() ? Range.lessThan(getUpper()) : Range.atMost(getUpper()); } else if (getUpper() == null) { range = isLowerStrict() ? Range.greaterThan(getLower()) : Range.atLeast(getLower()); } else { range = Range.range(getLower(), isLowerStrict() ? BoundType.OPEN : BoundType.CLOSED, getUpper(), isUpperStrict() ? BoundType.OPEN : BoundType.CLOSED); } retSet.add(range); return retSet; }
From source file:com.ibm.common.activitystreams.actions.Parameter.java
public <O extends Comparable<? super O>> Range<O> bounds() { O mini = minInclusive();// w ww . j a v a 2 s.c o m O mine = minExclusive(); O maxi = maxInclusive(); O maxe = maxExclusive(); Ordering<O> ordering = Ordering.<O>natural(); O min = ordering.nullsLast().min(mini, mine); O max = ordering.nullsFirst().max(maxi, maxe); BoundType lower = min == null ? null : min == mini ? BoundType.CLOSED : BoundType.OPEN; BoundType upper = max == null ? null : max == maxi ? BoundType.CLOSED : BoundType.OPEN; if (lower == null && upper == null) return Range.<O>all(); else if (lower != null && upper == null) return lower == BoundType.CLOSED ? Range.atLeast(min) : Range.greaterThan(min); else if (lower == null && upper != null) return upper == BoundType.CLOSED ? Range.atMost(max) : Range.lessThan(max); else { return Range.range(min, lower, max, upper); } }
From source file:com.palantir.atlasdb.keyvalue.cassandra.CassandraClientPool.java
private void refreshTokenRanges() { try {/*from ww w . j av a 2 s . co m*/ List<TokenRange> tokenRanges = getRandomGoodHost().runWithPooledResource(describeRing); ImmutableRangeMap.Builder<LightweightOPPToken, List<InetSocketAddress>> newTokenRing = ImmutableRangeMap .builder(); for (TokenRange tokenRange : tokenRanges) { List<InetSocketAddress> hosts = Lists.transform(tokenRange.getEndpoints(), new Function<String, InetSocketAddress>() { @Override public InetSocketAddress apply(String endpoint) { return new InetSocketAddress(endpoint, CassandraConstants.DEFAULT_THRIFT_PORT); } }); LightweightOPPToken startToken = new LightweightOPPToken( BaseEncoding.base16().decode(tokenRange.getStart_token().toUpperCase())); LightweightOPPToken endToken = new LightweightOPPToken( BaseEncoding.base16().decode(tokenRange.getEnd_token().toUpperCase())); if (startToken.compareTo(endToken) <= 0) { newTokenRing.put(Range.openClosed(startToken, endToken), hosts); } else { // Handle wrap-around newTokenRing.put(Range.greaterThan(startToken), hosts); newTokenRing.put(Range.atMost(endToken), hosts); } } tokenMap = newTokenRing.build(); } catch (Exception e) { log.error("Couldn't grab new token ranges for token aware cassandra mapping!", e); } }
From source file:org.apache.calcite.rex.RexSimplify.java
private static RexNode processRange(RexBuilder rexBuilder, List<RexNode> terms, Map<String, Pair<Range, List<RexNode>>> rangeTerms, RexNode term, RexNode ref, RexLiteral constant, SqlKind comparison) {/* w ww . j av a 2 s. co m*/ final Comparable v0 = constant.getValue(); Pair<Range, List<RexNode>> p = rangeTerms.get(ref.toString()); if (p == null) { Range r; switch (comparison) { case EQUALS: r = Range.singleton(v0); break; case LESS_THAN: r = Range.lessThan(v0); break; case LESS_THAN_OR_EQUAL: r = Range.atMost(v0); break; case GREATER_THAN: r = Range.greaterThan(v0); break; case GREATER_THAN_OR_EQUAL: r = Range.atLeast(v0); break; default: throw new AssertionError(); } rangeTerms.put(ref.toString(), new Pair(r, ImmutableList.of(term))); } else { // Exists boolean removeUpperBound = false; boolean removeLowerBound = false; Range r = p.left; switch (comparison) { case EQUALS: if (!r.contains(v0)) { // Range is empty, not satisfiable return rexBuilder.makeLiteral(false); } rangeTerms.put(ref.toString(), new Pair(Range.singleton(v0), ImmutableList.of(term))); // remove terms.removeAll(p.right); break; case LESS_THAN: { int comparisonResult = 0; if (r.hasUpperBound()) { comparisonResult = v0.compareTo(r.upperEndpoint()); } if (comparisonResult <= 0) { // 1) No upper bound, or // 2) We need to open the upper bound, or // 3) New upper bound is lower than old upper bound if (r.hasLowerBound()) { if (v0.compareTo(r.lowerEndpoint()) < 0) { // Range is empty, not satisfiable return rexBuilder.makeLiteral(false); } // a <= x < b OR a < x < b r = Range.range(r.lowerEndpoint(), r.lowerBoundType(), v0, BoundType.OPEN); } else { // x < b r = Range.lessThan(v0); } if (r.isEmpty()) { // Range is empty, not satisfiable return rexBuilder.makeLiteral(false); } // remove prev upper bound removeUpperBound = true; } else { // Remove this term as it is contained in current upper bound terms.remove(term); } break; } case LESS_THAN_OR_EQUAL: { int comparisonResult = -1; if (r.hasUpperBound()) { comparisonResult = v0.compareTo(r.upperEndpoint()); } if (comparisonResult < 0) { // 1) No upper bound, or // 2) New upper bound is lower than old upper bound if (r.hasLowerBound()) { if (v0.compareTo(r.lowerEndpoint()) < 0) { // Range is empty, not satisfiable return rexBuilder.makeLiteral(false); } // a <= x <= b OR a < x <= b r = Range.range(r.lowerEndpoint(), r.lowerBoundType(), v0, BoundType.CLOSED); } else { // x <= b r = Range.atMost(v0); } if (r.isEmpty()) { // Range is empty, not satisfiable return rexBuilder.makeLiteral(false); } // remove prev upper bound removeUpperBound = true; } else { // Remove this term as it is contained in current upper bound terms.remove(term); } break; } case GREATER_THAN: { int comparisonResult = 0; if (r.hasLowerBound()) { comparisonResult = v0.compareTo(r.lowerEndpoint()); } if (comparisonResult >= 0) { // 1) No lower bound, or // 2) We need to open the lower bound, or // 3) New lower bound is greater than old lower bound if (r.hasUpperBound()) { if (v0.compareTo(r.upperEndpoint()) > 0) { // Range is empty, not satisfiable return rexBuilder.makeLiteral(false); } // a < x <= b OR a < x < b r = Range.range(v0, BoundType.OPEN, r.upperEndpoint(), r.upperBoundType()); } else { // x > a r = Range.greaterThan(v0); } if (r.isEmpty()) { // Range is empty, not satisfiable return rexBuilder.makeLiteral(false); } // remove prev lower bound removeLowerBound = true; } else { // Remove this term as it is contained in current lower bound terms.remove(term); } break; } case GREATER_THAN_OR_EQUAL: { int comparisonResult = 1; if (r.hasLowerBound()) { comparisonResult = v0.compareTo(r.lowerEndpoint()); } if (comparisonResult > 0) { // 1) No lower bound, or // 2) New lower bound is greater than old lower bound if (r.hasUpperBound()) { if (v0.compareTo(r.upperEndpoint()) > 0) { // Range is empty, not satisfiable return rexBuilder.makeLiteral(false); } // a <= x <= b OR a <= x < b r = Range.range(v0, BoundType.CLOSED, r.upperEndpoint(), r.upperBoundType()); } else { // x >= a r = Range.atLeast(v0); } if (r.isEmpty()) { // Range is empty, not satisfiable return rexBuilder.makeLiteral(false); } // remove prev lower bound removeLowerBound = true; } else { // Remove this term as it is contained in current lower bound terms.remove(term); } break; } default: throw new AssertionError(); } if (removeUpperBound) { ImmutableList.Builder<RexNode> newBounds = ImmutableList.builder(); for (RexNode e : p.right) { if (e.isA(SqlKind.LESS_THAN) || e.isA(SqlKind.LESS_THAN_OR_EQUAL)) { terms.remove(e); } else { newBounds.add(e); } } newBounds.add(term); rangeTerms.put(ref.toString(), new Pair(r, newBounds.build())); } else if (removeLowerBound) { ImmutableList.Builder<RexNode> newBounds = ImmutableList.builder(); for (RexNode e : p.right) { if (e.isA(SqlKind.GREATER_THAN) || e.isA(SqlKind.GREATER_THAN_OR_EQUAL)) { terms.remove(e); } else { newBounds.add(e); } } newBounds.add(term); rangeTerms.put(ref.toString(), new Pair(r, newBounds.build())); } } // Default return null; }