Refine search
/** * Splits the provided {@link RowSet} along the provided splitPoint into 2 segments. The right * segment will contain all keys that are strictly greater than the splitPoint and all {@link * RowRange}s truncated to start right after the splitPoint. */ @Nonnull public static Split split(@Nonnull RowSet rowSet, @Nonnull ByteString splitPoint) { ImmutableSortedSet<ByteString> splitPoints = ImmutableSortedSet.orderedBy(ByteStringComparator.INSTANCE).add(splitPoint).build(); List<RowSet> splits = split(rowSet, splitPoints, true); return Split.of(splits.get(0), splits.get(1)); }
/** * Returns an immutable sorted set containing the given elements sorted by the given {@code * Comparator}. When multiple elements are equivalent according to {@code compareTo()}, only the * first one specified is included. * * @throws NullPointerException if {@code comparator} or any of {@code elements} is null */ public static <E> ImmutableSortedSet<E> copyOf( Comparator<? super E> comparator, Iterator<? extends E> elements) { return new Builder<E>(comparator).addAll(elements).build(); }
@GwtIncompatible // SerializableTester public void testDifferentComparator_serialization() { // don't use Collections.reverseOrder(); it didn't reserialize to the same instance in JDK5 Comparator<Comparable<?>> comparator = Ordering.natural().reverse(); SortedSet<String> set = new ImmutableSortedSet.Builder<String>(comparator).add("a", "b", "c").build(); SortedSet<String> copy = SerializableTester.reserializeAndAssert(set); assertTrue(Iterables.elementsEqual(set, copy)); assertEquals(set.comparator(), copy.comparator()); }
public Pipeline() { m_lock = new Object(); m_pipeline = ImmutableSortedSet.<FilterSubscriber>naturalOrder().build(); }
public void testToImmutableSortedSet_customComparator() { Collector<String, ?, ImmutableSortedSet<String>> collector = ImmutableSortedSet.toImmutableSortedSet(String.CASE_INSENSITIVE_ORDER); BiPredicate<ImmutableSortedSet<String>, ImmutableSortedSet<String>> equivalence = (set1, set2) -> set1.equals(set2) && set1.asList().equals(set2.asList()) && set1.comparator().equals(set2.comparator()); ImmutableSortedSet<String> expected = ImmutableSortedSet.orderedBy(String.CASE_INSENSITIVE_ORDER).add("a", "B", "c", "d").build(); CollectorTester.of(collector, equivalence) .expectCollects(expected, "a", "B", "a", "c", "b", "b", "d"); }
@Override protected List<String> create(String[] elements) { Comparator<String> comparator = createExplicitComparator(elements); ImmutableSortedSet.Builder<String> builder = ImmutableSortedSet.orderedBy(comparator); builder.add(BEFORE_FIRST); builder.add(elements); builder.add(AFTER_LAST); return builder.build().subSet(BEFORE_FIRST_2, AFTER_LAST).asList(); } }
@GwtIncompatible // NavigableSet public void testSubSet_unnaturalOrdering() { ImmutableSortedSet<Integer> set = ImmutableSortedSet.<Integer>reverseOrder().add(2, 4, 6, 8, 10).build(); try { Sets.subSet(set, Range.closed(4, 8)); fail("IllegalArgumentException expected"); } catch (IllegalArgumentException expected) { } // These results are all incorrect, but there's no way (short of iterating over the result) // to verify that with an arbitrary ordering or comparator. assertEquals(ImmutableSortedSet.of(2, 4), Sets.subSet(set, Range.atLeast(4))); assertEquals(ImmutableSortedSet.of(8, 10), Sets.subSet(set, Range.atMost(8))); assertEquals(ImmutableSortedSet.of(2, 4, 6, 8, 10), Sets.subSet(set, Range.<Integer>all())); } }
@Override protected List<String> create(String[] elements) { Comparator<String> comparator = createExplicitComparator(elements).reverse(); return ImmutableSortedSet.orderedBy(comparator) .add(elements) .build() .descendingSet() .asList(); } }
@Override protected List<String> create(String[] elements) { Comparator<String> comparator = createExplicitComparator(elements); ImmutableSortedSet.Builder<String> builder = ImmutableSortedSet.orderedBy(comparator); builder.add(BEFORE_FIRST); builder.add(elements); builder.add(AFTER_LAST); return builder.build().asList().subList(1, elements.length + 1); } }
@Override protected SortedSet<String> create(String[] elements) { return ImmutableSortedSet.<String>reverseOrder().add(elements).build().descendingSet(); } }
@Override protected SortedSet<String> create(String[] elements) { return ImmutableSortedSet.<String>reverseOrder() .addAll(Arrays.asList(elements).iterator()) .build(); }
public void testSupertypeComparatorSubtypeElements() { SortedSet<Number> set = new ImmutableSortedSet.Builder<Number>(TO_STRING).add(3, 12, 101, 44).build(); assertThat(set).containsExactly(101, 12, 3, 44).inOrder(); }
/** * Returns an immutable sorted set containing the given elements sorted by the given {@code * Comparator}. When multiple elements are equivalent according to {@code compareTo()}, only the * first one specified is included. * * @throws NullPointerException if {@code comparator} or any of {@code elements} is null */ public static <E> ImmutableSortedSet<E> copyOf( Comparator<? super E> comparator, Iterator<? extends E> elements) { return new Builder<E>(comparator).addAll(elements).build(); }
public void testSupertypeComparator() { SortedSet<Integer> set = new ImmutableSortedSet.Builder<Integer>(TO_STRING).add(3, 12, 101, 44).build(); assertThat(set).containsExactly(101, 12, 3, 44).inOrder(); }
/** * Returns a builder that creates immutable sorted sets with an explicit comparator. If the * comparator has a more general type than the set being generated, such as creating a {@code * SortedSet<Integer>} with a {@code Comparator<Number>}, use the {@link Builder} constructor * instead. * * @throws NullPointerException if {@code comparator} is null */ public static <E> Builder<E> orderedBy(Comparator<E> comparator) { return new Builder<E>(comparator); }
/** * Returns a builder that creates immutable sorted sets whose elements are ordered by the reverse * of their natural ordering. */ public static <E extends Comparable<?>> Builder<E> reverseOrder() { return new Builder<E>(Collections.reverseOrder()); }
/** * Returns a builder that creates immutable sorted sets whose elements are ordered by their * natural ordering. The sorted sets use {@link Ordering#natural()} as the comparator. This method * provides more type-safety than {@link #builder}, as it can be called only for classes that * implement {@link Comparable}. */ public static <E extends Comparable<?>> Builder<E> naturalOrder() { return new Builder<E>(Ordering.natural()); }
static <E> Collector<E, ?, ImmutableSortedSet<E>> toImmutableSortedSet( Comparator<? super E> comparator) { checkNotNull(comparator); return Collector.of( () -> new ImmutableSortedSet.Builder<E>(comparator), ImmutableSortedSet.Builder::add, ImmutableSortedSet.Builder::combine, ImmutableSortedSet.Builder::build); }