Remove outdated references to the "next release of Guava".

RELNOTES=n/a ------------- Created by MOE: https://github.com/google/moe MOE_MIGRATED_REVID=244709329
google · Apr 29, 2019 · d254e04 · d254e04
1 parent 1f20155
commit d254e04
Show file tree

Hide file tree

Showing 3 changed files with 36 additions and 46 deletions.
diff --git a/android/guava/src/com/google/common/collect/FluentIterable.java b/android/guava/src/com/google/common/collect/FluentIterable.java
@@ -610,9 +610,8 @@ public final boolean isEmpty() {
    * Returns an {@code ImmutableList} containing all of the elements from this fluent iterable in
    * proper sequence.
    *
-   * <p><b>{@code Stream} equivalent:</b> {@code ImmutableList.copyOf(stream.iterator())}, or after
-   * the next release of Guava, pass {@link ImmutableList#toImmutableList} to {@code
-   * stream.collect()}.
+   * <p><b>{@code Stream} equivalent:</b> {@code ImmutableList.copyOf(stream.iterator())}, or pass
+   * {@link ImmutableList#toImmutableList} to {@code stream.collect()}.
    *
    * @throws NullPointerException if any element is {@code null}
    * @since 14.0 (since 12.0 as {@code toImmutableList()}).
@@ -627,9 +626,8 @@ public final ImmutableList<E> toList() {
    * ImmutableList} sorted by its natural ordering, use {@code toSortedList(Ordering.natural())}.
    *
    * <p><b>{@code Stream} equivalent:</b> {@code
-   * ImmutableList.copyOf(stream.sorted(comparator).iterator())}, or after the next release of
-   * Guava, pass {@link ImmutableList#toImmutableList} to {@code
-   * stream.sorted(comparator).collect()}.
+   * ImmutableList.copyOf(stream.sorted(comparator).iterator())}, or pass {@link
+   * ImmutableList#toImmutableList} to {@code stream.sorted(comparator).collect()}.
    *
    * @param comparator the function by which to sort list elements
    * @throws NullPointerException if any element of this iterable is {@code null}
@@ -643,9 +641,8 @@ public final ImmutableList<E> toSortedList(Comparator<? super E> comparator) {
    * Returns an {@code ImmutableSet} containing all of the elements from this fluent iterable with
    * duplicates removed.
    *
-   * <p><b>{@code Stream} equivalent:</b> {@code ImmutableSet.copyOf(stream.iterator())}, or after
-   * the next release of Guava, pass {@link ImmutableSet#toImmutableSet} to {@code
-   * stream.collect()}.
+   * <p><b>{@code Stream} equivalent:</b> {@code ImmutableSet.copyOf(stream.iterator())}, or pass
+   * {@link ImmutableSet#toImmutableSet} to {@code stream.collect()}.
    *
    * @throws NullPointerException if any element is {@code null}
    * @since 14.0 (since 12.0 as {@code toImmutableSet()}).
@@ -661,8 +658,8 @@ public final ImmutableSet<E> toSet() {
    * by its natural ordering, use {@code toSortedSet(Ordering.natural())}.
    *
    * <p><b>{@code Stream} equivalent:</b> {@code ImmutableSortedSet.copyOf(comparator,
-   * stream.iterator())}, or after the next release of Guava, pass {@link
-   * ImmutableSortedSet#toImmutableSortedSet} to {@code stream.collect()}.
+   * stream.iterator())}, or pass {@link ImmutableSortedSet#toImmutableSortedSet} to {@code
+   * stream.collect()}.
    *
    * @param comparator the function by which to sort set elements
    * @throws NullPointerException if any element of this iterable is {@code null}
@@ -676,8 +673,7 @@ public final ImmutableSortedSet<E> toSortedSet(Comparator<? super E> comparator)
    * Returns an {@code ImmutableMultiset} containing all of the elements from this fluent iterable.
    *
    * <p><b>{@code Stream} equivalent:</b> {@code ImmutableMultiset.copyOf(stream.iterator())}, or
-   * after the next release of Guava, pass {@link ImmutableMultiset#toImmutableMultiset} to {@code
-   * stream.collect()}.
+   * pass {@link ImmutableMultiset#toImmutableMultiset} to {@code stream.collect()}.
    *
    * @throws NullPointerException if any element is null
    * @since 19.0
@@ -695,10 +691,10 @@ public final ImmutableMultiset<E> toMultiset() {
    * {@code valueFunction} will be applied to more than one instance of that key and, if it is,
    * which result will be mapped to that key in the returned map.
    *
-   * <p><b>{@code Stream} equivalent:</b> after the next release of Guava, use {@code
-   * stream.collect(ImmutableMap.toImmutableMap(k -> k, valueFunction))}. Before then you can use
-   * {@code ImmutableMap.copyOf(stream.collect(Collectors.toMap(k -> k, valueFunction)))}, but be
-   * aware that this may not preserve the order of entries.
+   * <p><b>{@code Stream} equivalent:</b> use {@code stream.collect(ImmutableMap.toImmutableMap(k ->
+   * k, valueFunction))}. Before then you can use {@code
+   * ImmutableMap.copyOf(stream.collect(Collectors.toMap(k -> k, valueFunction)))}, but be aware
+   * that this may not preserve the order of entries.
    *
    * @throws NullPointerException if any element of this iterable is {@code null}, or if {@code
    *     valueFunction} produces {@code null} for any key
@@ -748,7 +744,7 @@ public final <K> ImmutableListMultimap<K, E> index(Function<? super E, K> keyFun
    * <p>If your index may associate multiple values with each key, use {@link #index(Function)
    * index}.
    *
-   * <p><b>{@code Stream} equivalent:</b> after the next release of Guava, use {@code
+   * <p><b>{@code Stream} equivalent:</b> use {@code
    * stream.collect(ImmutableMap.toImmutableMap(keyFunction, v -> v))}. Before then you can use
    * {@code ImmutableMap.copyOf(stream.collect(Collectors.toMap(keyFunction, v -> v)))}, but be
    * aware that this may not preserve the order of entries.

diff --git a/android/guava/src/com/google/common/collect/Ordering.java b/android/guava/src/com/google/common/collect/Ordering.java
@@ -534,9 +534,8 @@ public <S extends T> Ordering<Iterable<S>> lexicographical() {
    * least values, the first of those is returned. The iterator will be left exhausted: its {@code
    * hasNext()} method will return {@code false}.
    *
-   * <p><b>Java 8 users:</b> Continue to use this method for now. After the next release of Guava,
-   * use {@code Streams.stream(iterator).min(thisComparator).get()} instead (but note that it does
-   * not guarantee which tied minimum element is returned).
+   * <p><b>Java 8 users:</b> Use {@code Streams.stream(iterator).min(thisComparator).get()} instead
+   * (but note that it does not guarantee which tied minimum element is returned).
    *
    * @param iterator the iterator whose minimum element is to be determined
    * @throws NoSuchElementException if {@code iterator} is empty
@@ -560,8 +559,7 @@ public <E extends T> E min(Iterator<E> iterator) {
    * least values, the first of those is returned.
    *
    * <p><b>Java 8 users:</b> If {@code iterable} is a {@link Collection}, use {@code
-   * Collections.min(collection, thisComparator)} instead. Otherwise, continue to use this method
-   * for now. After the next release of Guava, use {@code
+   * Collections.min(collection, thisComparator)} instead. Otherwise, use {@code
    * Streams.stream(iterable).min(thisComparator).get()} instead. Note that these alternatives do
    * not guarantee which tied minimum element is returned)
    *
@@ -622,9 +620,9 @@ public <E extends T> E min(@NullableDecl E a, @NullableDecl E b, @NullableDecl E
    * greatest values, the first of those is returned. The iterator will be left exhausted: its
    * {@code hasNext()} method will return {@code false}.
    *
-   * <p><b>Java 8 users:</b> Continue to use this method for now. After the next release of Guava,
-   * use {@code Streams.stream(iterator).max(thisComparator).get()} instead (but note that it does
-   * not guarantee which tied maximum element is returned).
+   * <p><b>Java 8 users:</b> Continue to use this method for now. Use {@code
+   * Streams.stream(iterator).max(thisComparator).get()} instead (but note that it does not
+   * guarantee which tied maximum element is returned).
    *
    * @param iterator the iterator whose maximum element is to be determined
    * @throws NoSuchElementException if {@code iterator} is empty
@@ -648,8 +646,7 @@ public <E extends T> E max(Iterator<E> iterator) {
    * greatest values, the first of those is returned.
    *
    * <p><b>Java 8 users:</b> If {@code iterable} is a {@link Collection}, use {@code
-   * Collections.max(collection, thisComparator)} instead. Otherwise, continue to use this method
-   * for now. After the next release of Guava, use {@code
+   * Collections.max(collection, thisComparator)} instead. Otherwise, use {@code
    * Streams.stream(iterable).max(thisComparator).get()} instead. Note that these alternatives do
    * not guarantee which tied maximum element is returned)
    *
@@ -749,8 +746,8 @@ public <E extends T> List<E> leastOf(Iterable<E> iterable, int k) {
    * <p>The implementation does not necessarily use a <i>stable</i> sorting algorithm; when multiple
    * elements are equivalent, it is undefined which will come first.
    *
-   * <p><b>Java 8 users:</b> Continue to use this method for now. After the next release of Guava,
-   * use {@code Streams.stream(iterator).collect(Comparators.least(k, thisComparator))} instead.
+   * <p><b>Java 8 users:</b> Use {@code Streams.stream(iterator).collect(Comparators.least(k,
+   * thisComparator))} instead.
    *
    * @return an immutable {@code RandomAccess} list of the {@code k} least elements in ascending
    *     order
@@ -809,8 +806,8 @@ public <E extends T> List<E> greatestOf(Iterable<E> iterable, int k) {
    * <p>The implementation does not necessarily use a <i>stable</i> sorting algorithm; when multiple
    * elements are equivalent, it is undefined which will come first.
    *
-   * <p><b>Java 8 users:</b> Continue to use this method for now. After the next release of Guava,
-   * use {@code Streams.stream(iterator).collect(Comparators.greatest(k, thisComparator))} instead.
+   * <p><b>Java 8 users:</b> Use {@code Streams.stream(iterator).collect(Comparators.greatest(k,
+   * thisComparator))} instead.
    *
    * @return an immutable {@code RandomAccess} list of the {@code k} greatest elements in
    *     <i>descending order</i>

diff --git a/guava/src/com/google/common/collect/Ordering.java b/guava/src/com/google/common/collect/Ordering.java
@@ -534,9 +534,8 @@ public <S extends T> Ordering<Iterable<S>> lexicographical() {
    * least values, the first of those is returned. The iterator will be left exhausted: its {@code
    * hasNext()} method will return {@code false}.
    *
-   * <p><b>Java 8 users:</b> Continue to use this method for now. After the next release of Guava,
-   * use {@code Streams.stream(iterator).min(thisComparator).get()} instead (but note that it does
-   * not guarantee which tied minimum element is returned).
+   * <p><b>Java 8 users:</b> Use {@code Streams.stream(iterator).min(thisComparator).get()} instead
+   * (but note that it does not guarantee which tied minimum element is returned).
    *
    * @param iterator the iterator whose minimum element is to be determined
    * @throws NoSuchElementException if {@code iterator} is empty
@@ -560,8 +559,7 @@ public <E extends T> E min(Iterator<E> iterator) {
    * least values, the first of those is returned.
    *
    * <p><b>Java 8 users:</b> If {@code iterable} is a {@link Collection}, use {@code
-   * Collections.min(collection, thisComparator)} instead. Otherwise, continue to use this method
-   * for now. After the next release of Guava, use {@code
+   * Collections.min(collection, thisComparator)} instead. Otherwise, use {@code
    * Streams.stream(iterable).min(thisComparator).get()} instead. Note that these alternatives do
    * not guarantee which tied minimum element is returned)
    *
@@ -622,9 +620,9 @@ public <E extends T> E min(@Nullable E a, @Nullable E b, @Nullable E c, E... res
    * greatest values, the first of those is returned. The iterator will be left exhausted: its
    * {@code hasNext()} method will return {@code false}.
    *
-   * <p><b>Java 8 users:</b> Continue to use this method for now. After the next release of Guava,
-   * use {@code Streams.stream(iterator).max(thisComparator).get()} instead (but note that it does
-   * not guarantee which tied maximum element is returned).
+   * <p><b>Java 8 users:</b> Continue to use this method for now. Use {@code
+   * Streams.stream(iterator).max(thisComparator).get()} instead (but note that it does not
+   * guarantee which tied maximum element is returned).
    *
    * @param iterator the iterator whose maximum element is to be determined
    * @throws NoSuchElementException if {@code iterator} is empty
@@ -648,8 +646,7 @@ public <E extends T> E max(Iterator<E> iterator) {
    * greatest values, the first of those is returned.
    *
    * <p><b>Java 8 users:</b> If {@code iterable} is a {@link Collection}, use {@code
-   * Collections.max(collection, thisComparator)} instead. Otherwise, continue to use this method
-   * for now. After the next release of Guava, use {@code
+   * Collections.max(collection, thisComparator)} instead. Otherwise, use {@code
    * Streams.stream(iterable).max(thisComparator).get()} instead. Note that these alternatives do
    * not guarantee which tied maximum element is returned)
    *
@@ -749,8 +746,8 @@ public <E extends T> List<E> leastOf(Iterable<E> iterable, int k) {
    * <p>The implementation does not necessarily use a <i>stable</i> sorting algorithm; when multiple
    * elements are equivalent, it is undefined which will come first.
    *
-   * <p><b>Java 8 users:</b> Continue to use this method for now. After the next release of Guava,
-   * use {@code Streams.stream(iterator).collect(Comparators.least(k, thisComparator))} instead.
+   * <p><b>Java 8 users:</b> Use {@code Streams.stream(iterator).collect(Comparators.least(k,
+   * thisComparator))} instead.
    *
    * @return an immutable {@code RandomAccess} list of the {@code k} least elements in ascending
    *     order
@@ -809,8 +806,8 @@ public <E extends T> List<E> greatestOf(Iterable<E> iterable, int k) {
    * <p>The implementation does not necessarily use a <i>stable</i> sorting algorithm; when multiple
    * elements are equivalent, it is undefined which will come first.
    *
-   * <p><b>Java 8 users:</b> Continue to use this method for now. After the next release of Guava,
-   * use {@code Streams.stream(iterator).collect(Comparators.greatest(k, thisComparator))} instead.
+   * <p><b>Java 8 users:</b> Use {@code Streams.stream(iterator).collect(Comparators.greatest(k,
+   * thisComparator))} instead.
    *
    * @return an immutable {@code RandomAccess} list of the {@code k} greatest elements in
    *     <i>descending order</i>