/** Returns an immutable sorted set containing a single element. */ public static <E extends Comparable<? super E>> ImmutableSortedSet<E> of(E element) { return new RegularImmutableSortedSet<E>(ImmutableList.of(element), Ordering.natural()); }
static <E> RegularImmutableSortedSet<E> emptySet(Comparator<? super E> comparator) { if (Ordering.natural().equals(comparator)) { return (RegularImmutableSortedSet<E>) RegularImmutableSortedSet.NATURAL_EMPTY_SET; } else { return new RegularImmutableSortedSet<E>(ImmutableList.<E>of(), comparator); } }
/** Returns an immutable map containing a single entry. */ private static <K, V> ImmutableSortedMap<K, V> of(Comparator<? super K> comparator, K k1, V v1) { return new ImmutableSortedMap<>( new RegularImmutableSortedSet<K>(ImmutableList.of(k1), checkNotNull(comparator)), ImmutableList.of(v1)); }
@Override public ImmutableSet<Range<C>> asRanges() { if (ranges.isEmpty()) { return ImmutableSet.of(); } return new RegularImmutableSortedSet<>(ranges, Range.<C>rangeLexOrdering()); }
@Override public ImmutableMap<Range<K>, V> asMapOfRanges() { if (ranges.isEmpty()) { return ImmutableMap.of(); } RegularImmutableSortedSet<Range<K>> rangeSet = new RegularImmutableSortedSet<>(ranges, Range.<K>rangeLexOrdering()); return new ImmutableSortedMap<>(rangeSet, values); }
static <E> RegularImmutableSortedSet<E> emptySet(Comparator<? super E> comparator) { if (Ordering.natural().equals(comparator)) { return (RegularImmutableSortedSet<E>) RegularImmutableSortedSet.NATURAL_EMPTY_SET; } else { return new RegularImmutableSortedSet<E>(ImmutableList.<E>of(), comparator); } }
/** Returns an immutable map containing a single entry. */ private static <K, V> ImmutableSortedMap<K, V> of(Comparator<? super K> comparator, K k1, V v1) { return new ImmutableSortedMap<>( new RegularImmutableSortedSet<K>(ImmutableList.of(k1), checkNotNull(comparator)), ImmutableList.of(v1)); }
private static <E> ImmutableSortedMultiset<E> copyOfSortedEntries( Comparator<? super E> comparator, Collection<Entry<E>> entries) { if (entries.isEmpty()) { return emptyMultiset(comparator); } ImmutableList.Builder<E> elementsBuilder = new ImmutableList.Builder<E>(entries.size()); long[] cumulativeCounts = new long[entries.size() + 1]; int i = 0; for (Entry<E> entry : entries) { elementsBuilder.add(entry.getElement()); cumulativeCounts[i + 1] = cumulativeCounts[i] + entry.getCount(); i++; } return new RegularImmutableSortedMultiset<E>( new RegularImmutableSortedSet<E>(elementsBuilder.build(), comparator), cumulativeCounts, 0, entries.size()); }
@Override public ImmutableSet<Range<C>> asDescendingSetOfRanges() { if (ranges.isEmpty()) { return ImmutableSet.of(); } return new RegularImmutableSortedSet<>(ranges.reverse(), Range.<C>rangeLexOrdering().reverse()); }
/** * Returns an immutable sorted set containing the elements of a sorted set, sorted by the same * {@code Comparator}. That behavior differs from {@link #copyOf(Iterable)}, which always uses the * natural ordering of the elements. * * <p>Despite the method name, this method attempts to avoid actually copying the data when it is * safe to do so. The exact circumstances under which a copy will or will not be performed are * undocumented and subject to change. * * <p>This method is safe to use even when {@code sortedSet} is a synchronized or concurrent * collection that is currently being modified by another thread. * * @throws NullPointerException if {@code sortedSet} or any of its elements is null */ public static <E> ImmutableSortedSet<E> copyOfSorted(SortedSet<E> sortedSet) { Comparator<? super E> comparator = SortedIterables.comparator(sortedSet); ImmutableList<E> list = ImmutableList.copyOf(sortedSet); if (list.isEmpty()) { return emptySet(comparator); } else { return new RegularImmutableSortedSet<E>(list, comparator); } }
@Override ImmutableSortedSet<E> createDescendingSet() { Comparator<? super E> reversedOrder = Collections.reverseOrder(comparator); return isEmpty() ? emptySet(reversedOrder) : new RegularImmutableSortedSet<E>(elements.reverse(), reversedOrder); } }
RegularImmutableSortedSet<E> getSubSet(int newFromIndex, int newToIndex) { if (newFromIndex == 0 && newToIndex == size()) { return this; } else if (newFromIndex < newToIndex) { return new RegularImmutableSortedSet<E>( elements.subList(newFromIndex, newToIndex), comparator); } else { return emptySet(comparator); } }
@Override public ImmutableMap<Range<K>, V> asDescendingMapOfRanges() { if (ranges.isEmpty()) { return ImmutableMap.of(); } RegularImmutableSortedSet<Range<K>> rangeSet = new RegularImmutableSortedSet<>(ranges.reverse(), Range.<K>rangeLexOrdering().reverse()); return new ImmutableSortedMap<>(rangeSet, values.reverse()); }
/** * Constructs an {@code ImmutableSortedSet} from the first {@code n} elements of {@code contents}. * If {@code k} is the size of the returned {@code ImmutableSortedSet}, then the sorted unique * elements are in the first {@code k} positions of {@code contents}, and {@code contents[i] == * null} for {@code k <= i < n}. * * <p>If {@code k == contents.length}, then {@code contents} may no longer be safe for * modification. * * @throws NullPointerException if any of the first {@code n} elements of {@code contents} is null */ static <E> ImmutableSortedSet<E> construct( Comparator<? super E> comparator, int n, E... contents) { if (n == 0) { return emptySet(comparator); } checkElementsNotNull(contents, n); Arrays.sort(contents, 0, n, comparator); int uniques = 1; for (int i = 1; i < n; i++) { E cur = contents[i]; E prev = contents[uniques - 1]; if (comparator.compare(cur, prev) != 0) { contents[uniques++] = cur; } } Arrays.fill(contents, uniques, n, null); return new RegularImmutableSortedSet<E>( ImmutableList.<E>asImmutableList(contents, uniques), comparator); }
/** * Returns a newly-created {@code ImmutableSortedSet} based on the contents of the {@code * Builder} and its comparator. */ @Override public ImmutableSortedSet<E> build() { sortAndDedup(); if (n == 0) { return emptySet(comparator); } else { forceCopy = true; return new RegularImmutableSortedSet<E>( ImmutableList.asImmutableList(elements, n), comparator); } } }
@GwtIncompatible // super.subListUnchecked does not exist; inherited subList is valid if slow /* * TODO(cpovirk): if we start to override indexOf/lastIndexOf under GWT, we'll want some way to * override subList to return an ImmutableSortedAsList for better performance. Right now, I'm not * sure there's any performance hit from our failure to override subListUnchecked under GWT */ @Override ImmutableList<E> subListUnchecked(int fromIndex, int toIndex) { ImmutableList<E> parentSubList = super.subListUnchecked(fromIndex, toIndex); return new RegularImmutableSortedSet<E>(parentSubList, comparator()).asList(); }
@Override ImmutableSortedSet<E> createDescendingSet() { Comparator<? super E> reversedOrder = Collections.reverseOrder(comparator); return isEmpty() ? emptySet(reversedOrder) : new RegularImmutableSortedSet<E>(elements.reverse(), reversedOrder); } }
RegularImmutableSortedSet<E> getSubSet(int newFromIndex, int newToIndex) { if (newFromIndex == 0 && newToIndex == size()) { return this; } else if (newFromIndex < newToIndex) { return new RegularImmutableSortedSet<E>( elements.subList(newFromIndex, newToIndex), comparator); } else { return emptySet(comparator); } }
@GwtIncompatible // super.subListUnchecked does not exist; inherited subList is valid if slow /* * TODO(cpovirk): if we start to override indexOf/lastIndexOf under GWT, we'll want some way to * override subList to return an ImmutableSortedAsList for better performance. Right now, I'm not * sure there's any performance hit from our failure to override subListUnchecked under GWT */ @Override ImmutableList<E> subListUnchecked(int fromIndex, int toIndex) { ImmutableList<E> parentSubList = super.subListUnchecked(fromIndex, toIndex); return new RegularImmutableSortedSet<E>(parentSubList, comparator()).asList(); }
@GwtIncompatible // super.subListUnchecked does not exist; inherited subList is valid if slow /* * TODO(cpovirk): if we start to override indexOf/lastIndexOf under GWT, we'll want some way to * override subList to return an ImmutableSortedAsList for better performance. Right now, I'm not * sure there's any performance hit from our failure to override subListUnchecked under GWT */ @Override ImmutableList<E> subListUnchecked(int fromIndex, int toIndex) { ImmutableList<E> parentSubList = super.subListUnchecked(fromIndex, toIndex); return new RegularImmutableSortedSet<E>(parentSubList, comparator()).asList(); }