Make toImmutableEnum[Set|Map] to AndroidAccessToCollectors

I think that’s the last of them. The implementations I moved verbatim, and there was no change of code there. RELNOTES=n/a ------------- Created by MOE: https://github.com/google/moe MOE_MIGRATED_REVID=342853260
melloware · Nov 17, 2020 · 751d7c0 · 751d7c0
1 parent c8eb421
commit 751d7c0
Show file tree

Hide file tree

Showing 3 changed files with 119 additions and 97 deletions.
diff --git a/guava/src/com/google/common/collect/CollectCollectors.java b/guava/src/com/google/common/collect/CollectCollectors.java
@@ -24,6 +24,8 @@
 import com.google.common.base.Preconditions;
 import java.util.Collection;
 import java.util.Comparator;
+import java.util.EnumMap;
+import java.util.EnumSet;
 import java.util.LinkedHashMap;
 import java.util.TreeMap;
 import java.util.function.BinaryOperator;
@@ -33,6 +35,7 @@
 import java.util.stream.Collector;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
+import org.checkerframework.checker.nullness.qual.Nullable;
 
 /** Collectors utilities for {@code common.collect} internals. */
 @GwtCompatible
@@ -85,6 +88,48 @@ final class CollectCollectors {
         ImmutableSortedSet.Builder::build);
   }
 
+  @SuppressWarnings({"rawtypes", "unchecked"})
+  static <E extends Enum<E>> Collector<E, ?, ImmutableSet<E>> toImmutableEnumSet() {
+    return (Collector) EnumSetAccumulator.TO_IMMUTABLE_ENUM_SET;
+  }
+
+  private static final class EnumSetAccumulator<E extends Enum<E>> {
+    @SuppressWarnings({"rawtypes", "unchecked"})
+    static final Collector<Enum<?>, ?, ImmutableSet<? extends Enum<?>>> TO_IMMUTABLE_ENUM_SET =
+        (Collector)
+            Collector.<Enum, EnumSetAccumulator, ImmutableSet<?>>of(
+                EnumSetAccumulator::new,
+                EnumSetAccumulator::add,
+                EnumSetAccumulator::combine,
+                EnumSetAccumulator::toImmutableSet,
+                Collector.Characteristics.UNORDERED);
+
+    private @Nullable EnumSet<E> set;
+
+    void add(E e) {
+      if (set == null) {
+        set = EnumSet.of(e);
+      } else {
+        set.add(e);
+      }
+    }
+
+    EnumSetAccumulator<E> combine(EnumSetAccumulator<E> other) {
+      if (this.set == null) {
+        return other;
+      } else if (other.set == null) {
+        return this;
+      } else {
+        this.set.addAll(other.set);
+        return this;
+      }
+    }
+
+    ImmutableSet<E> toImmutableSet() {
+      return (set == null) ? ImmutableSet.<E>of() : ImmutableEnumSet.asImmutable(set);
+    }
+  }
+
   @GwtIncompatible
   @SuppressWarnings({"rawtypes", "unchecked"})
   static <E extends Comparable<? super E>>
@@ -198,6 +243,77 @@ final class CollectCollectors {
         new Collector.Characteristics[0]);
   }
 
+  static <T, K extends Enum<K>, V> Collector<T, ?, ImmutableMap<K, V>> toImmutableEnumMap(
+      Function<? super T, ? extends K> keyFunction,
+      Function<? super T, ? extends V> valueFunction) {
+    checkNotNull(keyFunction);
+    checkNotNull(valueFunction);
+    return Collector.of(
+        () ->
+            new EnumMapAccumulator<K, V>(
+                (v1, v2) -> {
+                  throw new IllegalArgumentException("Multiple values for key: " + v1 + ", " + v2);
+                }),
+        (accum, t) -> {
+          K key = checkNotNull(keyFunction.apply(t), "Null key for input %s", t);
+          V newValue = checkNotNull(valueFunction.apply(t), "Null value for input %s", t);
+          accum.put(key, newValue);
+        },
+        EnumMapAccumulator::combine,
+        EnumMapAccumulator::toImmutableMap,
+        Collector.Characteristics.UNORDERED);
+  }
+
+  static <T, K extends Enum<K>, V> Collector<T, ?, ImmutableMap<K, V>> toImmutableEnumMap(
+      Function<? super T, ? extends K> keyFunction,
+      Function<? super T, ? extends V> valueFunction,
+      BinaryOperator<V> mergeFunction) {
+    checkNotNull(keyFunction);
+    checkNotNull(valueFunction);
+    checkNotNull(mergeFunction);
+    // not UNORDERED because we don't know if mergeFunction is commutative
+    return Collector.of(
+        () -> new EnumMapAccumulator<K, V>(mergeFunction),
+        (accum, t) -> {
+          K key = checkNotNull(keyFunction.apply(t), "Null key for input %s", t);
+          V newValue = checkNotNull(valueFunction.apply(t), "Null value for input %s", t);
+          accum.put(key, newValue);
+        },
+        EnumMapAccumulator::combine,
+        EnumMapAccumulator::toImmutableMap);
+  }
+
+  private static class EnumMapAccumulator<K extends Enum<K>, V> {
+    private final BinaryOperator<V> mergeFunction;
+    private EnumMap<K, V> map = null;
+
+    EnumMapAccumulator(BinaryOperator<V> mergeFunction) {
+      this.mergeFunction = mergeFunction;
+    }
+
+    void put(K key, V value) {
+      if (map == null) {
+        map = new EnumMap<>(key.getDeclaringClass());
+      }
+      map.merge(key, value, mergeFunction);
+    }
+
+    EnumMapAccumulator<K, V> combine(EnumMapAccumulator<K, V> other) {
+      if (this.map == null) {
+        return other;
+      } else if (other.map == null) {
+        return this;
+      } else {
+        other.map.forEach(this::put);
+        return this;
+      }
+    }
+
+    ImmutableMap<K, V> toImmutableMap() {
+      return (map == null) ? ImmutableMap.<K, V>of() : ImmutableEnumMap.asImmutable(map);
+    }
+  }
+
   @GwtIncompatible
   static <T, K extends Comparable<? super K>, V>
       Collector<T, ?, ImmutableRangeMap<K, V>> toImmutableRangeMap(

diff --git a/guava/src/com/google/common/collect/Maps.java b/guava/src/com/google/common/collect/Maps.java
@@ -171,37 +171,6 @@ public static <K extends Enum<K>, V> ImmutableMap<K, V> immutableEnumMap(
     return ImmutableEnumMap.asImmutable(enumMap);
   }
 
-  private static class Accumulator<K extends Enum<K>, V> {
-    private final BinaryOperator<V> mergeFunction;
-    private EnumMap<K, V> map = null;
-
-    Accumulator(BinaryOperator<V> mergeFunction) {
-      this.mergeFunction = mergeFunction;
-    }
-
-    void put(K key, V value) {
-      if (map == null) {
-        map = new EnumMap<>(key.getDeclaringClass());
-      }
-      map.merge(key, value, mergeFunction);
-    }
-
-    Accumulator<K, V> combine(Accumulator<K, V> other) {
-      if (this.map == null) {
-        return other;
-      } else if (other.map == null) {
-        return this;
-      } else {
-        other.map.forEach(this::put);
-        return this;
-      }
-    }
-
-    ImmutableMap<K, V> toImmutableMap() {
-      return (map == null) ? ImmutableMap.<K, V>of() : ImmutableEnumMap.asImmutable(map);
-    }
-  }
-
   /**
    * Returns a {@link Collector} that accumulates elements into an {@code ImmutableMap} whose keys
    * and values are the result of applying the provided mapping functions to the input elements. The
@@ -219,22 +188,7 @@ ImmutableMap<K, V> toImmutableMap() {
   public static <T, K extends Enum<K>, V> Collector<T, ?, ImmutableMap<K, V>> toImmutableEnumMap(
       java.util.function.Function<? super T, ? extends K> keyFunction,
       java.util.function.Function<? super T, ? extends V> valueFunction) {
-    checkNotNull(keyFunction);
-    checkNotNull(valueFunction);
-    return Collector.of(
-        () ->
-            new Accumulator<K, V>(
-                (v1, v2) -> {
-                  throw new IllegalArgumentException("Multiple values for key: " + v1 + ", " + v2);
-                }),
-        (accum, t) -> {
-          K key = checkNotNull(keyFunction.apply(t), "Null key for input %s", t);
-          V newValue = checkNotNull(valueFunction.apply(t), "Null value for input %s", t);
-          accum.put(key, newValue);
-        },
-        Accumulator::combine,
-        Accumulator::toImmutableMap,
-        Collector.Characteristics.UNORDERED);
+    return CollectCollectors.toImmutableEnumMap(keyFunction, valueFunction);
   }
 
   /**
@@ -252,19 +206,7 @@ ImmutableMap<K, V> toImmutableMap() {
       java.util.function.Function<? super T, ? extends K> keyFunction,
       java.util.function.Function<? super T, ? extends V> valueFunction,
       BinaryOperator<V> mergeFunction) {
-    checkNotNull(keyFunction);
-    checkNotNull(valueFunction);
-    checkNotNull(mergeFunction);
-    // not UNORDERED because we don't know if mergeFunction is commutative
-    return Collector.of(
-        () -> new Accumulator<K, V>(mergeFunction),
-        (accum, t) -> {
-          K key = checkNotNull(keyFunction.apply(t), "Null key for input %s", t);
-          V newValue = checkNotNull(valueFunction.apply(t), "Null value for input %s", t);
-          accum.put(key, newValue);
-        },
-        Accumulator::combine,
-        Accumulator::toImmutableMap);
+    return CollectCollectors.toImmutableEnumMap(keyFunction, valueFunction, mergeFunction);
   }
 
   /**

diff --git a/guava/src/com/google/common/collect/Sets.java b/guava/src/com/google/common/collect/Sets.java
@@ -137,42 +137,6 @@ public static <E extends Enum<E>> ImmutableSet<E> immutableEnumSet(Iterable<E> e
     }
   }
 
-  private static final class Accumulator<E extends Enum<E>> {
-    static final Collector<Enum<?>, ?, ImmutableSet<? extends Enum<?>>> TO_IMMUTABLE_ENUM_SET =
-        (Collector)
-            Collector.<Enum, Accumulator, ImmutableSet<?>>of(
-                Accumulator::new,
-                Accumulator::add,
-                Accumulator::combine,
-                Accumulator::toImmutableSet,
-                Collector.Characteristics.UNORDERED);
-
-    private @Nullable EnumSet<E> set;
-
-    void add(E e) {
-      if (set == null) {
-        set = EnumSet.of(e);
-      } else {
-        set.add(e);
-      }
-    }
-
-    Accumulator<E> combine(Accumulator<E> other) {
-      if (this.set == null) {
-        return other;
-      } else if (other.set == null) {
-        return this;
-      } else {
-        this.set.addAll(other.set);
-        return this;
-      }
-    }
-
-    ImmutableSet<E> toImmutableSet() {
-      return (set == null) ? ImmutableSet.<E>of() : ImmutableEnumSet.asImmutable(set);
-    }
-  }
-
   /**
    * Returns a {@code Collector} that accumulates the input elements into a new {@code ImmutableSet}
    * with an implementation specialized for enums. Unlike {@link ImmutableSet#toImmutableSet}, the
@@ -181,7 +145,7 @@ ImmutableSet<E> toImmutableSet() {
    * @since 21.0
    */
   public static <E extends Enum<E>> Collector<E, ?, ImmutableSet<E>> toImmutableEnumSet() {
-    return (Collector) Accumulator.TO_IMMUTABLE_ENUM_SET;
+    return CollectCollectors.toImmutableEnumSet();
   }
 
   /**