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

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

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

Introduction

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

Prototype

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

Source Link

Document

Returns a range that contains all values less than or equal to endpoint .

Usage

From source file:com.android.build.gradle.integration.common.utils.AndroidVersionMatcher.java

public static Matcher<AndroidVersion> atMost(int version) {
    return forRange(Range.atMost(version));
}

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.
 * //from w w  w  . ja v a2  s  .c om
 * @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;/*  ww w  .j a  v a2s. c  o  m*/
    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:org.graylog2.commands.journal.JournalDecode.java

@Override
protected void runCommand() {

    Range<Long> range;/* ww w . j  a v a  2s  .co  m*/
    try {
        final List<String> offsets = Splitter.on("..").limit(2).splitToList(rangeArg);
        if (offsets.size() == 1) {
            range = Range.singleton(Long.valueOf(offsets.get(0)));
        } else if (offsets.size() == 2) {
            final String first = offsets.get(0);
            final String second = offsets.get(1);
            if (first.isEmpty()) {
                range = Range.atMost(Long.valueOf(second));
            } else if (second.isEmpty()) {
                range = Range.atLeast(Long.valueOf(first));
            } else {
                range = Range.closed(Long.valueOf(first), Long.valueOf(second));
            }
        } else {
            throw new RuntimeException();
        }
    } catch (Exception e) {
        System.err.println("Malformed offset range: " + rangeArg);
        return;
    }

    final Map<String, Codec.Factory<? extends Codec>> codecFactory = injector
            .getInstance(Key.get(new TypeLiteral<Map<String, Codec.Factory<? extends Codec>>>() {
            }));

    final Long readOffset = range.lowerEndpoint();
    final long count = range.upperEndpoint() - range.lowerEndpoint() + 1;
    final List<Journal.JournalReadEntry> entries = journal.read(readOffset, count);
    for (final Journal.JournalReadEntry entry : entries) {
        final RawMessage raw = RawMessage.decode(entry.getPayload(), entry.getOffset());
        if (raw == null) {
            System.err.println(
                    MessageFormatter.format("Journal entry at offset {} failed to decode", entry.getOffset()));
            continue;
        }

        final Codec codec = codecFactory.get(raw.getCodecName()).create(raw.getCodecConfig());
        final Message message = codec.decode(raw);
        if (message == null) {
            System.err.println(
                    MessageFormatter.format("Could not use codec {} to decode raw message id {} at offset {}",
                            new Object[] { raw.getCodecName(), raw.getId(), entry.getOffset() }));
        } else {
            message.setJournalOffset(raw.getJournalOffset());
        }

        final ResolvableInetSocketAddress remoteAddress = raw.getRemoteAddress();
        final String remote = remoteAddress == null ? "unknown address"
                : remoteAddress.getInetSocketAddress().toString();

        final StringBuffer sb = new StringBuffer();
        sb.append("Message ").append(raw.getId()).append('\n').append(" at ").append(raw.getTimestamp())
                .append('\n').append(" in format ").append(raw.getCodecName()).append('\n')
                .append(" at offset ").append(raw.getJournalOffset()).append('\n')
                .append(" received from remote address ").append(remote).append('\n').append(" (source field: ")
                .append(message == null ? "unparsed" : message.getSource()).append(')').append('\n');
        if (message != null) {
            sb.append(" contains ").append(message.getFieldNames().size()).append(" fields.");
        } else {
            sb.append("The message could not be parse by the given codec.");
        }
        System.out.println(sb);
    }

}

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  va2  s .co  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:io.druid.timeline.partition.SingleDimensionShardSpec.java

@Override
public Map<String, Range<String>> getDomain() {
    Range<String> range;//  w w  w  . j a v  a  2s  .co  m
    if (start == null && end == null) {
        range = Range.all();
    } else if (start == null) {
        range = Range.atMost(end);
    } else if (end == null) {
        range = Range.atLeast(start);
    } else {
        range = Range.closed(start, end);
    }
    return ImmutableMap.of(dimension, range);
}

From source file:org.apache.druid.timeline.partition.SingleDimensionShardSpec.java

private Range<String> getRange() {
    Range<String> range;/*w w w . j a v  a 2s . c om*/
    if (start == null && end == null) {
        range = Range.all();
    } else if (start == null) {
        range = Range.atMost(end);
    } else if (end == null) {
        range = Range.atLeast(start);
    } else {
        range = Range.closed(start, end);
    }
    return range;
}

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  .  ja v a 2 s  . c  o  m*/
    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:org.openmhealth.dsu.domain.DataPointSearchCriteriaBuilder.java

public DataPointSearchCriteriaBuilder setCreationTimestampUpperEndpoint(OffsetDateTime upperEndpoint) {
    this.creationTimestampUpperEndpoint = upperEndpoint != null ? Range.atMost(upperEndpoint) : Range.all();
    return this;
}

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

/**
 * remove from self the elements that exist in other
 * @return/*from   w  ww .  j a  v  a2 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;

}