예제 #1
0
 public static <T extends Comparable<T>> Range<T> parse(String value, Function<String, T> parser) {
   Validate.notNull(parser, "Parser is required");
   if (StringUtils.isBlank(value) || StringUtils.equals(SEPARATOR, value)) {
     return Ranges.all();
   } else if (!StringUtils.contains(value, SEPARATOR)) {
     T element = parser.apply(value);
     return Ranges.atMost(element);
   } else {
     String lower = StringUtils.substringBefore(value, SEPARATOR);
     String upper = StringUtils.substringAfter(value, SEPARATOR);
     if (StringUtils.isBlank(lower)) {
       // ..n
       Pair<T, BoundType> boundary = parseUpperBoundary(upper, parser);
       return Ranges.upTo(boundary.getLeft(), boundary.getRight());
     } else if (StringUtils.isBlank(upper)) {
       // n..
       Pair<T, BoundType> boundary = parseLowerBoundary(lower, parser);
       return Ranges.downTo(boundary.getLeft(), boundary.getRight());
     } else {
       // n..m
       Pair<T, BoundType> down = parseLowerBoundary(lower, parser);
       Pair<T, BoundType> up = parseUpperBoundary(upper, parser);
       return Ranges.range(down.getLeft(), down.getRight(), up.getLeft(), up.getRight());
     }
   }
 }
예제 #2
0
 @Test
 public void isConnected() {
   assertThat(Ranges.closed(3, 5).isConnected(Ranges.open(5, 10)), is(true));
   assertThat(Ranges.closed(0, 9).isConnected(Ranges.closed(3, 4)), is(true));
   assertThat(Ranges.closed(0, 5).isConnected(Ranges.closed(3, 9)), is(true));
   assertThat(Ranges.open(3, 5).isConnected(Ranges.open(5, 10)), is(false));
   assertThat(Ranges.closed(1, 5).isConnected(Ranges.closed(6, 10)), is(false));
 }
예제 #3
0
 protected final ContiguousSet<Integer> checkedCreate(SortedSet<Integer> elementsSet) {
   List<Integer> elements = newArrayList(elementsSet);
   /*
    * A ContiguousSet can't have holes. If a test demands a hole, it should be changed so that it
    * doesn't need one, or it should be suppressed for ContiguousSet.
    */
   for (int i = 0; i < elements.size() - 1; i++) {
     assertEquals(elements.get(i) + 1, (int) elements.get(i + 1));
   }
   Range<Integer> range =
       (elements.isEmpty()) ? Ranges.closedOpen(0, 0) : Ranges.encloseAll(elements);
   return range.asSet(DiscreteDomains.integers());
 }
예제 #4
0
 @Test
 public void openClosed() {
   System.out.println("## openClosed ##");
   Range<Integer> range = Ranges.openClosed(0, 10);
   System.out.println(range);
   printAllElements(range);
 }
예제 #5
0
 @Test
 public void closedOpen() {
   System.out.println("## closedOpen ##");
   Range<Integer> range = Ranges.closedOpen(0, 10);
   System.out.println(range);
   printAllElements(range);
 }
    public static List<Range<Integer>> parseToRange(String value) {
      List<Range<Integer>> validRanges = new ArrayList<Range<Integer>>();

      String[] codes = value.split(",");
      for (String code : codes) {
        String[] fromTo = code.trim().split(":");
        checkArgument(
            fromTo.length <= 2, "Code %s should be an interval from:to or a single value", code);

        Integer from;
        try {
          from = Integer.parseInt(fromTo[0]);
        } catch (NumberFormatException nfe) {
          throw new IllegalArgumentException("Invalid number " + fromTo[0]);
        }

        Integer to = from;
        if (fromTo.length != 1) {
          try {
            to = Integer.parseInt(fromTo[1]);
          } catch (NumberFormatException nfe) {
            throw new IllegalArgumentException("Invalid number " + fromTo[1]);
          }
        }

        checkArgument(from <= to, "Interval %s should be FROM less than TO", code);
        validRanges.add(Ranges.closed(from, to));
      }

      return validRanges;
    }
예제 #7
0
 @Test
 public void filterUsingLessThan() {
   List<Double> scores = Lists.newArrayList(3.0, 3.5, 4.0, 4.5, 5.0);
   double median = getMedian(scores);
   List<Double> belowMedian =
       Lists.newArrayList(Iterables.filter(scores, Ranges.lessThan(median)));
   System.out.println(belowMedian);
 }
예제 #8
0
 @Override
 protected SortedSet<Integer> create(Integer[] elements) {
   SortedSet<Integer> set = nullCheckedTreeSet(elements);
   if (set.isEmpty()) {
     /*
      * The (tooLow + 1, tooHigh) arguments below would be invalid because tooLow would be
      * greater than tooHigh.
      */
     return Ranges.openClosed(0, 1).asSet(DiscreteDomains.integers()).subSet(0, 1);
   }
   int tooHigh = set.last() + 1;
   int tooLow = set.first() - 1;
   set.add(tooHigh);
   set.add(tooLow);
   return checkedCreate(set).subSet(tooLow + 1, tooHigh);
 }
 private List<ScheduledCommand> createMoveCommands(final double length) {
   if (Math.abs(length) < 1) {
     return ImmutableList.<ScheduledCommand>of();
   }
   final double currentAngle = workspace.getCurrentAngle();
   final ScheduledCommand command =
       new ScheduledCommand() {
         @Override
         public void execute() {
           workspace.updatePosition(length > 0 ? 1.0 : -1.0, currentAngle);
         }
       };
   final Function<Integer, ScheduledCommand> function =
       new Function<Integer, ScheduledCommand>() {
         @Override
         public ScheduledCommand apply(Integer input) {
           return command;
         }
       };
   final List<Integer> range =
       Ranges.closed(1, (int) length).asSet(DiscreteDomains.integers()).asList();
   return transform(range, function);
 }
예제 #10
0
 @Test
 public void span() {
   assertThat(Ranges.closed(3, 5).span(Ranges.open(5, 10)), is(Ranges.closedOpen(3, 10)));
   assertThat(Ranges.closed(0, 9).span(Ranges.closed(3, 4)), is(Ranges.closed(0, 9)));
   assertThat(Ranges.closed(0, 5).span(Ranges.closed(3, 9)), is(Ranges.closed(0, 9)));
   assertThat(Ranges.open(3, 5).span(Ranges.open(5, 10)), is(Ranges.open(3, 10)));
   assertThat(Ranges.closed(1, 5).span(Ranges.closed(6, 10)), is(Ranges.closed(1, 10)));
 }
예제 #11
0
 @Test(expected = IllegalArgumentException.class)
 public void intersectionWhenNoIntersectionFound() {
   Ranges.open(3, 5).intersection(Ranges.open(5, 10));
 }
예제 #12
0
 @Test
 public void intersection() {
   assertThat(Ranges.closed(3, 5).intersection(Ranges.open(5, 10)), is(Ranges.openClosed(5, 5)));
   assertThat(Ranges.closed(0, 9).intersection(Ranges.closed(3, 4)), is(Ranges.closed(3, 4)));
   assertThat(Ranges.closed(0, 5).intersection(Ranges.closed(3, 9)), is(Ranges.closed(3, 5)));
 }