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

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

Introduction

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

Prototype

public static <C extends Comparable<?>> Range<C> openClosed(C lower, C upper) 

Source Link

Document

Returns a range that contains all values strictly greater than lower and less than or equal to upper .

Usage

From source file:org.apache.niolex.common.guava.GuavaCollections.java

/**
 * @param args//  w  w  w. jav  a 2 s  . c o  m
 */
public static void main(String[] args) {
    Multiset<String> wordsMultiset = HashMultiset.create();
    wordsMultiset.add("abc");
    wordsMultiset.add("abc");
    wordsMultiset.add("abcd");
    System.out.println("count => " + wordsMultiset.count("abc"));
    System.out.println("count => " + wordsMultiset.count("abcd"));

    BiMap<String, String> biMap = HashBiMap.create();
    biMap.put("good", "morning");
    biMap.put("bad", "afternoon");
    System.out.println("good => " + biMap.get("good"));
    System.out.println("afternoon => " + biMap.inverse().get("afternoon"));

    RangeMap<Integer, String> rangeMap = TreeRangeMap.create();
    rangeMap.put(Range.closed(1, 11), "Nice");
    rangeMap.put(Range.openClosed(11, 15), "Girl");
    System.out.println("11 => " + rangeMap.get(11));
    System.out.println("12 => " + rangeMap.get(12));
    System.out.println("15 => " + rangeMap.get(15));
    System.out.println("16 => " + rangeMap.get(16));

    List<Integer> countUp = Ints.asList(1, 2, 3, 4, 5);
    List<Integer> countDown = Lists.reverse(countUp); // {5, 4, 3, 2, 1}
    System.out.println("countUp => " + countUp);
    System.out.println("countDown => " + countDown);
}

From source file:org.pentaho.di.trans.dataservice.jdbc.RowsResultSet.java

@Override
protected Object[] retrieveRow(int i) throws Exception {
    return Range.openClosed(0, rows.size()).contains(i) ? rows.get(i - 1) : null;
}

From source file:org.sosy_lab.cpachecker.cfa.CSourceOriginMapping.java

void mapInputLineRangeToDelta(String inputFilename, String originFilename, int fromInputLineNumber,
        int toInputLineNumber, int deltaLinesToOrigin) {
    RangeMap<Integer, Pair<String, Integer>> fileMapping = mapping.get(inputFilename);
    if (fileMapping == null) {
        fileMapping = TreeRangeMap.create();
        mapping.put(inputFilename, fileMapping);
    }// w w  w. j  av  a  2  s .com

    Range<Integer> lineRange = Range.openClosed(fromInputLineNumber - 1, toInputLineNumber);
    fileMapping.put(lineRange, Pair.of(originFilename, deltaLinesToOrigin));
}

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 .j  ava 2  s  .c o m*/
 * @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:crud.http.util.FailedResponseOperator.java

/**
 * Treat all non-200-range responses as errors.
 *//*from   w ww.  j ava2s.  c o  m*/
public static FailedResponseOperator nonSuccessResponses() {
    if (nonSuccessResponses == null) {
        final ImmutableSet<Integer> prefix = ContiguousSet
                .create(Range.closedOpen(MIN_STATUS_CODE, MIN_SUCCESS_STATUS_CODE), DiscreteDomain.integers());
        final ImmutableSet<Integer> suffix = ContiguousSet
                .create(Range.openClosed(MAX_SUCCESS_STATUS_CODE, MAX_STATUS_CODE), DiscreteDomain.integers());
        final ImmutableSet<Integer> all = ImmutableSet.<Integer>builder().addAll(prefix).addAll(suffix).build();
        // Don't delegate to fromStatusCodes(): it does extraneous checking
        nonSuccessResponses = new FailedResponseOperator(all);
    }
    return nonSuccessResponses;
}

From source file:net.bican.iplib.IPAddresses.java

private static Set<Range<IPAddress>> fromConnectedInterval(final Range<IPAddress> interval) {
    if (interval.isEmpty()) {
        return null;
    }/*  w w  w  .  j  av a 2s.  com*/
    int prefix = 0;
    final LongDiscreteDomain<IPAddress> domain = interval.lowerEndpoint().getDomain();
    while (prefix <= domain.maxPrefix()) {
        final Range<IPAddress> thisRange = IPAddresses.canonical(interval, domain);
        final Range<IPAddress> otherRange = IPAddresses.fromCIDR(new CIDR(thisRange.lowerEndpoint(), prefix));
        if (thisRange.equals(otherRange)) {
            TreeSet<Range<IPAddress>> result = new TreeSet<>(IPAddressRangeComparator.getComparator());
            result.add(otherRange);
            return result;
        } else if (thisRange.encloses(otherRange)) {
            final Set<Range<IPAddress>> result = new TreeSet<>(IPAddressRangeComparator.getComparator());
            result.add(otherRange);
            Range<IPAddress> newRange1 = Range.closedOpen(thisRange.lowerEndpoint(),
                    otherRange.lowerEndpoint());
            Range<IPAddress> newRange2 = Range.openClosed(otherRange.upperEndpoint(),
                    thisRange.upperEndpoint());
            final Set<Range<IPAddress>> results1 = IPAddresses.fromConnectedInterval(newRange1);
            if (results1 != null) {
                result.addAll(results1);
            }
            final Set<Range<IPAddress>> results2 = IPAddresses.fromConnectedInterval(newRange2);
            if (results2 != null) {
                result.addAll(results2);
            }
            return result;
        }
        prefix++;
    }
    return new TreeSet<>(Collections.singleton(interval));
}

From source file:org.dishevelled.bio.range.rtree.RangeGeometries.java

/**
 * Create and return a new rectangle geometry from the specified open closed range <code>(lower..upper]</code>
 *
 * @param <N> value type/*from   ww w .ja v a2 s  . c  om*/
 * @param lower lower endpoint, must not be null
 * @param upper upper endpoint, must not be null
 * @return a new rectangle geometry from the specified closed range
 */
public static <N extends Number & Comparable<? super N>> Rectangle openClosed(final N lower, final N upper) {
    checkNotNull(lower);
    checkNotNull(upper);
    return range(Range.openClosed(lower, upper));
}

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//  w w w.  ja va2s.co m

    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.ja  v a2 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.apache.kylin.common.util.RangeUtil.java

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

}