Lines Matching refs:comparator
31 import java.util.Comparator;
40 * Some instances are ordered by an explicit comparator, while others follow the
61 * two elements are equivalent. Instead, with an explicit comparator, the
65 * {(x, y) | comparator.compare(x, y) == 0}}</pre>
92 private static final Comparator<Comparable> NATURAL_ORDER =
104 Comparator<? super E> comparator) {
105 if (NATURAL_ORDER.equals(comparator)) {
108 return new EmptyImmutableSortedSet<E>(comparator);
217 * copy of a {@code SortedSet} that preserves the comparator, call {@link
252 * copy of a {@code SortedSet} that preserves the comparator, call
308 * the given {@code Comparator}. When multiple elements are equivalent
312 * @throws NullPointerException if {@code comparator} or any of
316 Comparator<? super E> comparator, Iterator<? extends E> elements) {
317 checkNotNull(comparator);
318 return copyOfInternal(comparator, elements);
323 * the given {@code Comparator}. When multiple elements are equivalent
331 * @throws NullPointerException if {@code comparator} or any of {@code
335 Comparator<? super E> comparator, Iterable<? extends E> elements) {
336 checkNotNull(comparator);
337 return copyOfInternal(comparator, elements);
342 * the given {@code Comparator}. When multiple elements are equivalent
354 * @throws NullPointerException if {@code comparator} or any of
359 Comparator<? super E> comparator, Collection<? extends E> elements) {
360 checkNotNull(comparator);
361 return copyOfInternal(comparator, elements);
366 * sorted by the same {@code Comparator}. That behavior differs from {@link
383 Comparator<? super E> comparator = sortedSet.comparator();
384 if (comparator == null) {
385 comparator = (Comparator<? super E>) NATURAL_ORDER;
387 return copyOfInternal(comparator, sortedSet);
391 Comparator<? super E> comparator, Iterable<? extends E> elements) {
393 SortedIterables.hasSameComparator(comparator, elements);
403 SortedIterables.sortedUnique(comparator, elements));
405 ? ImmutableSortedSet.<E>emptySet(comparator)
406 : new RegularImmutableSortedSet<E>(list, comparator);
410 Comparator<? super E> comparator, Iterator<? extends E> elements) {
412 ImmutableList.copyOf(SortedIterables.sortedUnique(comparator, elements));
414 ? ImmutableSortedSet.<E>emptySet(comparator)
415 : new RegularImmutableSortedSet<E>(list, comparator);
420 * comparator. If the comparator has a more general type than the set being
422 * {@code Comparator<Number>}, use the {@link Builder} constructor instead.
424 * @throws NullPointerException if {@code comparator} is null
426 public static <E> Builder<E> orderedBy(Comparator<E> comparator) {
427 return new Builder<E>(comparator);
446 * Ordering#natural()} as the comparator. This method provides more
461 * public static final} sets ("constant sets"), with a given comparator.
477 private final Comparator<? super E> comparator;
483 public Builder(Comparator<? super E> comparator) {
484 this.comparator = checkNotNull(comparator);
543 * of the {@code Builder} and its comparator.
546 return copyOfInternal(comparator, contents.iterator());
551 return unsafeCompare(comparator, a, b);
555 Comparator<?> comparator, Object a, Object b) {
556 // Pretend the comparator can compare anything. If it turns out it can't
560 Comparator<Object> unsafeComparator = (Comparator<Object>) comparator;
564 final transient Comparator<? super E> comparator;
566 ImmutableSortedSet(Comparator<? super E> comparator) {
567 this.comparator = comparator;
571 * Returns the comparator that orders the elements, which is
574 * {@link SortedSet#comparator()}, which returns {@code null} to indicate
578 public Comparator<? super E> comparator() {
579 return comparator;
627 checkArgument(comparator.compare(fromElement, toElement) <= 0);
674 final Comparator<? super E> comparator;
677 public SerializedForm(Comparator<? super E> comparator, Object[] elements) {
678 this.comparator = comparator;
684 return new Builder<E>(comparator).add((E[]) elements).build();
696 return new SerializedForm<E>(comparator, toArray());
