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

Introduction

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

Prototype

public static <C extends Comparable<?>> Range<C> downTo(C endpoint, BoundType boundType) 

Source Link

Document

Returns a range from the given endpoint, which may be either inclusive (closed) or exclusive (open), with no upper bound.

Usage

From source file:google.registry.model.common.PersistedRangeLong.java

public Range<Long> asRange() {
    Range<Long> range = Range.all();
    if (lowerBound != null) {
        range = range.intersection(Range.downTo(lowerBound, lowerBoundType));
    }/*from  w w w.  j  a v  a  2  s  . c  om*/
    if (upperBound != null) {
        range = range.intersection(Range.upTo(upperBound, upperBoundType));
    }
    return range;
}

---

From source file:com.techshroom.wood.ModuleDependency.java

public static ModuleDependency fromString(String dependency) {
    // Dependency format: '<id>:<version>'
    // List format: '<dep>;<dep>;<dep>'
    // Version range format:
    // Any version: [0.0.0,) or * or omitted
    // Any version above 1.0.0: [1.0.0,)
    // Any version with major 1: [1.0.0,2.0.0)
    // Any version with major.minor 1.0: [1.0.0,1.1.0)
    // 1.0.0-1.2.0: [1.0.0,1.2.0]
    // etc. Basically works like Range.
    String id;/* www.  j a  va  2  s  .c  om*/
    Range<SemVer> range;
    String[] idSplit = dependency.split(":", 2);
    id = idSplit[0];
    if (idSplit.length == 2 && !idSplit[1].equals("*")) {
        String r = idSplit[1];
        Matcher matcher = VERSION_RANGE_PATTERN.matcher(r);

        checkArgument(matcher.matches(), "'%s' is not a valid range", r);

        BoundType lowBound = matcher.group(1).equals("(") ? BoundType.OPEN : BoundType.CLOSED;
        BoundType hiBound = matcher.group(4).equals(")") ? BoundType.OPEN : BoundType.CLOSED;
        String lowVersion = matcher.group(2);
        String hiVersion = matcher.group(3);
        checkArgument(lowVersion != null || hiVersion != null,
                "A bound must have at least one version. Use \"[0.0.0,)\" or '*' for any.");
        if (lowVersion == null) {
            checkArgument(lowBound == BoundType.OPEN, "must use '(' with no lower bound");
            range = Range.upTo(SemVer.fromString(hiVersion), hiBound);
        } else if (hiVersion == null) {
            checkArgument(hiBound == BoundType.OPEN, "must use ')' with no upper bound");
            range = Range.downTo(SemVer.fromString(lowVersion), lowBound);
        } else {
            range = Range.range(SemVer.fromString(lowVersion), lowBound, SemVer.fromString(hiVersion), hiBound);
        }
    } else {
        range = Range.downTo(ZERO, BoundType.CLOSED);
    }
    return fromFields(id, range);
}

---

From source file:org.apache.lens.server.api.driver.hooks.QueryCostBasedQueryHook.java

public Range<T> parseRange(String rangeStr) {
    if (rangeStr == null) {
        return null;
    }//from   w  w  w.j  av  a  2 s.  com
    rangeStr = rangeStr.trim();
    BoundType lowerBound, upperBound;
    if (rangeStr.startsWith("[")) {
        lowerBound = BoundType.CLOSED;
    } else if (rangeStr.startsWith("(")) {
        lowerBound = BoundType.OPEN;
    } else {
        throw new IllegalArgumentException("Range should start with either ( or [");
    }
    if (rangeStr.endsWith("]")) {
        upperBound = BoundType.CLOSED;
    } else if (rangeStr.endsWith(")")) {
        upperBound = BoundType.OPEN;
    } else {
        throw new IllegalArgumentException("Range should end with either ) or ]");
    }
    String[] pair = rangeStr.substring(1, rangeStr.length() - 1).split(",");
    String leftStr = pair[0].trim();
    String rightStr = pair[1].trim();
    if (leftStr.isEmpty() && rightStr.isEmpty()) {
        return Range.all();
    } else if (leftStr.isEmpty()) {
        return Range.upTo(parser.parse(rightStr), upperBound);
    } else if (rightStr.isEmpty()) {
        return Range.downTo(parser.parse(leftStr), lowerBound);
    } else {
        return Range.range(parser.parse(leftStr), lowerBound, parser.parse(rightStr), upperBound);
    }
}

---

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

private static Range<Long> toLongRange(final Range<BoundValue> range) {
    if (!range.hasUpperBound() && !range.hasLowerBound()) {
        return Range.all();
    } else if (range.hasUpperBound() && !range.hasLowerBound()) {
        return Range.upTo(Long.parseLong(range.upperEndpoint().getValue()), range.upperBoundType());
    } else if (!range.hasUpperBound() && range.hasLowerBound()) {
        return Range.downTo(Long.parseLong(range.lowerEndpoint().getValue()), range.lowerBoundType());
    } else {//  www  . ja va  2  s .com
        return Range.range(Long.parseLong(range.lowerEndpoint().getValue()), range.lowerBoundType(),
                Long.parseLong(range.upperEndpoint().getValue()), range.upperBoundType());
    }
}

---

From source file:net.sourceforge.ganttproject.task.algorithm.SchedulerImpl.java

private void schedule(Node node) {
    Logger logger = GPLogger.getLogger(this);
    GPLogger.debug(logger, "Scheduling node %s", node);
    Range<Date> startRange = Range.all();
    Range<Date> endRange = Range.all();

    Range<Date> weakStartRange = Range.all();
    Range<Date> weakEndRange = Range.all();

    List<Date> subtaskRanges = Lists.newArrayList();
    List<DependencyEdge> incoming = node.getIncoming();
    GPLogger.debug(logger, ".. #incoming edges=%d", incoming.size());
    for (DependencyEdge edge : incoming) {
        if (!edge.refresh()) {
            continue;
        }//from   w  w w  . j  ava2  s  .  co m
        if (edge instanceof ImplicitSubSuperTaskDependency) {
            subtaskRanges.add(edge.getStartRange().upperEndpoint());
            subtaskRanges.add(edge.getEndRange().lowerEndpoint());
        } else {
            if (edge.isWeak()) {
                weakStartRange = weakStartRange.intersection(edge.getStartRange());
                weakEndRange = weakEndRange.intersection(edge.getEndRange());
            } else {
                startRange = startRange.intersection(edge.getStartRange());
                endRange = endRange.intersection(edge.getEndRange());
            }
        }
        if (startRange.isEmpty() || endRange.isEmpty()) {
            GPLogger.logToLogger("both start and end ranges were calculated as empty for task=" + node.getTask()
                    + ". Skipping it");
        }
    }
    GPLogger.debug(logger, "..Ranges: start=%s end=%s weakStart=%s weakEnd=%s", startRange, endRange,
            weakStartRange, weakEndRange);

    Range<Date> subtasksSpan = subtaskRanges.isEmpty()
            ? Range.closed(node.getTask().getStart().getTime(), node.getTask().getEnd().getTime())
            : Range.encloseAll(subtaskRanges);
    Range<Date> subtreeStartUpwards = subtasksSpan
            .span(Range.downTo(node.getTask().getStart().getTime(), BoundType.CLOSED));
    Range<Date> subtreeEndDownwards = subtasksSpan
            .span(Range.upTo(node.getTask().getEnd().getTime(), BoundType.CLOSED));
    GPLogger.debug(logger, "..Subtasks span=%s", subtasksSpan);

    if (!startRange.equals(Range.all())) {
        startRange = startRange.intersection(weakStartRange);
    } else if (!weakStartRange.equals(Range.all())) {
        startRange = weakStartRange.intersection(subtreeStartUpwards);
    }
    if (!endRange.equals(Range.all())) {
        endRange = endRange.intersection(weakEndRange);
    } else if (!weakEndRange.equals(Range.all())) {
        endRange = weakEndRange.intersection(subtreeEndDownwards);
    }
    if (node.getTask().getThirdDateConstraint() == TaskImpl.EARLIESTBEGIN
            && node.getTask().getThird() != null) {
        startRange = startRange
                .intersection(Range.downTo(node.getTask().getThird().getTime(), BoundType.CLOSED));
        GPLogger.debug(logger, ".. applying earliest start=%s. Now start range=%s", node.getTask().getThird(),
                startRange);
    }
    if (!subtaskRanges.isEmpty()) {
        startRange = startRange.intersection(subtasksSpan);
        endRange = endRange.intersection(subtasksSpan);
    }
    GPLogger.debug(logger, ".. finally, start range=%s", startRange);
    if (startRange.hasLowerBound()) {
        modifyTaskStart(node.getTask(), startRange.lowerEndpoint());
    }
    if (endRange.hasUpperBound()) {
        GPCalendarCalc cal = node.getTask().getManager().getCalendar();
        Date endDate = endRange.upperEndpoint();
        TimeUnit timeUnit = node.getTask().getDuration().getTimeUnit();
        if (DayMask.WORKING == (cal.getDayMask(endDate) & DayMask.WORKING)) {
            // in case if calculated end date falls on first day after holidays (say, on Monday)
            // we'll want to modify it a little bit, so that it falls on that holidays start
            // If we don't do this, it will be done automatically the next time task activities are recalculated,
            // and thus task end date will keep changing
            Date closestWorkingEndDate = cal.findClosest(endDate, timeUnit,
                    GPCalendarCalc.MoveDirection.BACKWARD, GPCalendar.DayType.WORKING);
            Date closestNonWorkingEndDate = cal.findClosest(endDate, timeUnit,
                    GPCalendarCalc.MoveDirection.BACKWARD, GPCalendar.DayType.NON_WORKING,
                    closestWorkingEndDate);
            // If there is a non-working date between current task end and closest working date
            // then we're really just after holidays
            if (closestNonWorkingEndDate != null && closestWorkingEndDate.before(closestNonWorkingEndDate)) {
                // we need to adjust-right closest working date to position to the very beginning of the holidays interval
                Date nonWorkingPeriodStart = timeUnit.adjustRight(closestWorkingEndDate);
                if (nonWorkingPeriodStart.after(node.getTask().getStart().getTime())) {
                    endDate = nonWorkingPeriodStart;
                }
            }
        }
        modifyTaskEnd(node.getTask(), endDate);
    }
}

---

From source file:org.apache.cassandra.cql3.restrictions.TokenFilter.java

/**
 * Converts the specified slice into a range set.
 *
 * @param slice the slice to convert/*www .ja  v  a  2s  .c  o  m*/
 * @param options the query option
 * @return the range set corresponding to the specified slice
 * @throws InvalidRequestException if the request is invalid
 */
private static RangeSet<Token> toRangeSet(TokenRestriction slice, QueryOptions options)
        throws InvalidRequestException {
    if (slice.hasBound(START)) {
        Token start = deserializeToken(slice.bounds(START, options).get(0));

        BoundType startBoundType = toBoundType(slice.isInclusive(START));

        if (slice.hasBound(END)) {
            BoundType endBoundType = toBoundType(slice.isInclusive(END));
            Token end = deserializeToken(slice.bounds(END, options).get(0));

            if (start.equals(end) && (BoundType.OPEN == startBoundType || BoundType.OPEN == endBoundType))
                return ImmutableRangeSet.of();

            if (start.compareTo(end) <= 0)
                return ImmutableRangeSet.of(Range.range(start, startBoundType, end, endBoundType));

            return ImmutableRangeSet.<Token>builder().add(Range.upTo(end, endBoundType))
                    .add(Range.downTo(start, startBoundType)).build();
        }
        return ImmutableRangeSet.of(Range.downTo(start, startBoundType));
    }
    Token end = deserializeToken(slice.bounds(END, options).get(0));
    return ImmutableRangeSet.of(Range.upTo(end, toBoundType(slice.isInclusive(END))));
}

---

From source file:org.immutables.mongo.repository.internal.Support.java

@SuppressWarnings("unchecked")
public static <T extends Comparable<T>> Range<Comparable<Object>> writable(TypeAdapter<T> adapter,
        Range<T> range) {/*from   w  ww . java  2  s.co  m*/
    if (range.hasLowerBound() && range.hasUpperBound()) {
        return Range.range((Comparable<Object>) writable(adapter, range.lowerEndpoint()),
                range.lowerBoundType(), (Comparable<Object>) writable(adapter, range.upperEndpoint()),
                range.upperBoundType());
    } else if (range.hasLowerBound()) {
        return Range.downTo((Comparable<Object>) writable(adapter, range.lowerEndpoint()),
                range.lowerBoundType());
    } else if (range.hasUpperBound()) {
        return Range.upTo((Comparable<Object>) writable(adapter, range.upperEndpoint()),
                range.upperBoundType());
    }
    throw new AssertionError();
}

---

From source file:com.tinspx.util.base.NumberUtils.java

@SuppressWarnings("unchecked")
public static Range<Long> toLongRange(@NonNull Range<? extends Number> range) {
    if (range.hasLowerBound()) {
        if (range.hasUpperBound()) {
            if (range.lowerEndpoint() instanceof Long && range.upperEndpoint() instanceof Long) {
                return (Range<Long>) range;
            }/*from  w  w  w.  ja  va 2  s. co m*/
            return Range.range(range.lowerEndpoint().longValue(), range.lowerBoundType(),
                    range.upperEndpoint().longValue(), range.upperBoundType());
        } else {
            if (range.lowerEndpoint() instanceof Long) {
                return (Range<Long>) range;
            }
            return Range.downTo(range.lowerEndpoint().longValue(), range.lowerBoundType());
        }
    } else if (range.hasUpperBound()) {
        if (range.upperEndpoint() instanceof Long) {
            return (Range<Long>) range;
        }
        return Range.upTo(range.upperEndpoint().longValue(), range.upperBoundType());
    } else {
        return Range.all();
    }
}

---

From source file:com.tinspx.util.base.NumberUtils.java

@SuppressWarnings("rawtypes")
public static <F extends Comparable, T extends Comparable> Range<T> transform(@NonNull Range<F> range,
        @NonNull Function<? super F, ? extends T> function) {
    if (range.hasLowerBound()) {
        if (range.hasUpperBound()) {
            return Range.range(function.apply(range.lowerEndpoint()), range.lowerBoundType(),
                    function.apply(range.upperEndpoint()), range.upperBoundType());
        } else {//from  ww  w  .j  a  v a 2s.c o m
            return Range.downTo(function.apply(range.lowerEndpoint()), range.lowerBoundType());
        }
    } else if (range.hasUpperBound()) {
        return Range.upTo(function.apply(range.upperEndpoint()), range.upperBoundType());
    } else {
        return Range.all();
    }
}

---

From source file:org.nmdp.ngs.fca.Interval.java

/**
 * Find the interval that extends ahead of this one.
 * @return interval with lower endpoint equal to this upper endpoint and
 * upper endpoint equal to infinity//w  w w  .  jav  a  2 s.c  o m
 * @see #behind() 
 */
public Interval<C> ahead() {
    if (this.hasNone()) {
        return new Interval(this.dimension, Range.all());
    }
    if (this.range.equals(Range.all())) {
        return new Interval(this.dimension);
    }
    return new Interval(this.dimension,
            Range.downTo(this.range.upperEndpoint(), reverse(this.range.upperBoundType())));
}

---