public boolean contains(K value) { return range.contains(value); }
/** * @deprecated Provided only to satisfy the {@link Predicate} interface; use {@link #contains} * instead. */ @Deprecated @Override public boolean apply(C input) { return contains(input); }
@Override public boolean contains(@Nullable Object object) { if (object == null) { return false; } try { return range.contains((C) object); } catch (ClassCastException e) { return false; } }
private static void putModel(Map<Integer, Integer> model, Range<Integer> range, int value) { for (int i = MIN_BOUND - 1; i <= MAX_BOUND + 1; i++) { if (range.contains(i)) { model.put(i, value); } } }
private static void removeModel(Map<Integer, Integer> model, Range<Integer> range) { for (int i = MIN_BOUND - 1; i <= MAX_BOUND + 1; i++) { if (range.contains(i)) { model.remove(i); } } } }
@Override public @Nullable Range<C> rangeContaining(C value) { checkNotNull(value); Entry<Cut<C>, Range<C>> floorEntry = rangesByLowerBound.floorEntry(Cut.belowValue(value)); if (floorEntry != null && floorEntry.getValue().contains(value)) { return floorEntry.getValue(); } else { // TODO(kevinb): revisit this design choice return null; } }
@Override public Range<C> rangeContaining(C value) { int index = SortedLists.binarySearch( ranges, Range.<C>lowerBoundFn(), Cut.belowValue(value), Ordering.natural(), ANY_PRESENT, NEXT_LOWER); if (index != -1) { Range<C> range = ranges.get(index); return range.contains(value) ? range : null; } return null; }
@Override public @Nullable Entry<Range<K>, V> getEntry(K key) { int index = SortedLists.binarySearch( ranges, Range.<K>lowerBoundFn(), Cut.belowValue(key), KeyPresentBehavior.ANY_PRESENT, KeyAbsentBehavior.NEXT_LOWER); if (index == -1) { return null; } else { Range<K> range = ranges.get(index); return range.contains(key) ? Maps.immutableEntry(range, values.get(index)) : null; } }
@Override public @Nullable V get(K key) { int index = SortedLists.binarySearch( ranges, Range.<K>lowerBoundFn(), Cut.belowValue(key), KeyPresentBehavior.ANY_PRESENT, KeyAbsentBehavior.NEXT_LOWER); if (index == -1) { return null; } else { Range<K> range = ranges.get(index); return range.contains(key) ? values.get(index) : null; } }
@Override protected Entry<Cut<C>, Range<C>> computeNext() { if (!completeRangeItr.hasNext()) { return endOfData(); } Range<C> nextRange = completeRangeItr.next(); if (restriction.lowerBound.compareTo(nextRange.upperBound) >= 0) { return endOfData(); } nextRange = nextRange.intersection(restriction); if (lowerBoundWindow.contains(nextRange.lowerBound)) { return Maps.immutableEntry(nextRange.lowerBound, nextRange); } else { return endOfData(); } } };
public void testGreaterThan() { Range<Integer> range = Range.greaterThan(5); assertFalse(range.contains(5)); assertTrue(range.contains(6)); assertTrue(range.contains(Integer.MAX_VALUE)); assertTrue(range.hasLowerBound()); assertEquals(5, (int) range.lowerEndpoint()); assertEquals(OPEN, range.lowerBoundType()); assertUnboundedAbove(range); assertFalse(range.isEmpty()); assertEquals("(5..+\u221e)", range.toString()); reserializeAndAssert(range); }
public void testAtLeast() { Range<Integer> range = Range.atLeast(6); assertFalse(range.contains(5)); assertTrue(range.contains(6)); assertTrue(range.contains(Integer.MAX_VALUE)); assertTrue(range.hasLowerBound()); assertEquals(6, (int) range.lowerEndpoint()); assertEquals(CLOSED, range.lowerBoundType()); assertUnboundedAbove(range); assertFalse(range.isEmpty()); assertEquals("[6..+\u221e)", range.toString()); reserializeAndAssert(range); }
public void testLessThan() { Range<Integer> range = Range.lessThan(5); assertTrue(range.contains(Integer.MIN_VALUE)); assertTrue(range.contains(4)); assertFalse(range.contains(5)); assertUnboundedBelow(range); assertTrue(range.hasUpperBound()); assertEquals(5, (int) range.upperEndpoint()); assertEquals(OPEN, range.upperBoundType()); assertFalse(range.isEmpty()); assertEquals("(-\u221e..5)", range.toString()); reserializeAndAssert(range); }
public void testAtMost() { Range<Integer> range = Range.atMost(4); assertTrue(range.contains(Integer.MIN_VALUE)); assertTrue(range.contains(4)); assertFalse(range.contains(5)); assertUnboundedBelow(range); assertTrue(range.hasUpperBound()); assertEquals(4, (int) range.upperEndpoint()); assertEquals(CLOSED, range.upperBoundType()); assertFalse(range.isEmpty()); assertEquals("(-\u221e..4]", range.toString()); reserializeAndAssert(range); }
public void testDoublyBoundedAgainstRange() { for (BoundType lboundType : BoundType.values()) { for (BoundType uboundType : BoundType.values()) { Range<Integer> range = Range.range(2, lboundType, 4, uboundType); GeneralRange<Integer> gRange = GeneralRange.range(ORDERING, 2, lboundType, 4, uboundType); for (Integer i : IN_ORDER_VALUES) { assertEquals(i != null && range.contains(i), gRange.contains(i)); } } } }
public void testAll() { Range<Integer> range = Range.all(); assertTrue(range.contains(Integer.MIN_VALUE)); assertTrue(range.contains(Integer.MAX_VALUE)); assertUnboundedBelow(range); assertUnboundedAbove(range); assertFalse(range.isEmpty()); assertEquals("(-\u221e..+\u221e)", range.toString()); assertSame(range, reserializeAndAssert(range)); assertSame(range, Range.all()); }
public void testSingleton() { Range<Integer> range = Range.closed(4, 4); assertFalse(range.contains(3)); assertTrue(range.contains(4)); assertFalse(range.contains(5)); assertTrue(range.hasLowerBound()); assertEquals(4, (int) range.lowerEndpoint()); assertEquals(CLOSED, range.lowerBoundType()); assertTrue(range.hasUpperBound()); assertEquals(4, (int) range.upperEndpoint()); assertEquals(CLOSED, range.upperBoundType()); assertFalse(range.isEmpty()); assertEquals("[4..4]", range.toString()); reserializeAndAssert(range); }
public void testEmpty1() { Range<Integer> range = Range.closedOpen(4, 4); assertFalse(range.contains(3)); assertFalse(range.contains(4)); assertFalse(range.contains(5)); assertTrue(range.hasLowerBound()); assertEquals(4, (int) range.lowerEndpoint()); assertEquals(CLOSED, range.lowerBoundType()); assertTrue(range.hasUpperBound()); assertEquals(4, (int) range.upperEndpoint()); assertEquals(OPEN, range.upperBoundType()); assertTrue(range.isEmpty()); assertEquals("[4..4)", range.toString()); reserializeAndAssert(range); }
public void testEmpty2() { Range<Integer> range = Range.openClosed(4, 4); assertFalse(range.contains(3)); assertFalse(range.contains(4)); assertFalse(range.contains(5)); assertTrue(range.hasLowerBound()); assertEquals(4, (int) range.lowerEndpoint()); assertEquals(OPEN, range.lowerBoundType()); assertTrue(range.hasUpperBound()); assertEquals(4, (int) range.upperEndpoint()); assertEquals(CLOSED, range.upperBoundType()); assertTrue(range.isEmpty()); assertEquals("(4..4]", range.toString()); reserializeAndAssert(range); }