* invoke methods, they invoke methods on the {@code ForwardingMultimap}.
 *
 * @author Robert Konigsberg
 * @since 2.0
 */
@GwtCompatible
public abstract class ForwardingMultimap<K extends @Nullable Object, V extends @Nullable Object>
    extends ForwardingObject implements Multimap<K, V> {

  /** Constructor for use by subclasses. */
  protected ForwardingMultimap() {}

  @Override
  protected abstract Multimap<K, V> delegate();

    CHECKED(IOException.class),
    UNCHECKED(RuntimeException.class);

    final Class<? extends Exception> exceptionType;

    ExceptionType(Class<? extends Exception> exceptionType) {
      this.exceptionType = exceptionType;
    }
  }

  private static final ImmutableSet<Class<? extends Exception>> OTHER_EXCEPTION_TYPES =
      ImmutableSet.of(
          BackingStoreException.class,

 *
 * @author Mike Bostock
 * @since 2.0
 */
@GwtCompatible
@J2ktIncompatible
public final class EnumBiMap<K extends Enum<K>, V extends Enum<V>> extends AbstractBiMap<K, V> {
  /*
   * J2CL's EnumMap does not need the Class instance, so we can use Object.class instead. (Or we

  }

  @Override
  public <T extends @Nullable Object> List<Future<T>> invokeAll(
      Collection<? extends Callable<T>> tasks) throws InterruptedException {
    return delegate().invokeAll(tasks);
  }

  @Override
  public <T extends @Nullable Object> List<Future<T>> invokeAll(
      Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
      throws InterruptedException {

/**
 * Implementation of {@link Multimaps#filterKeys(Multimap, Predicate)}.
 *
 * @author Louis Wasserman
 */
@GwtCompatible
class FilteredKeyMultimap<K extends @Nullable Object, V extends @Nullable Object>
    extends AbstractMultimap<K, V> implements FilteredMultimap<K, V> {
  final Multimap<K, V> unfiltered;
  final Predicate<? super K> keyPredicate;

public final class ListGenerators {

  private ListGenerators() {}

  public static class ImmutableListOfGenerator extends TestStringListGenerator {
    @Override
    protected List<String> create(String[] elements) {
      return ImmutableList.copyOf(elements);
    }
  }

  public static class BuilderAddListGenerator extends TestStringListGenerator {
    @Override
    protected List<String> create(String[] elements) {

  @SuppressWarnings("unchecked")
  private static <T extends @Nullable Object> ListenableFuture<? extends T>[] gwtCompatibleToArray(
      Iterable<? extends ListenableFuture<? extends T>> futures) {
    Collection<ListenableFuture<? extends T>> collection;
    if (futures instanceof Collection) {
      collection = (Collection<ListenableFuture<? extends T>>) futures;
    } else {
      collection = ImmutableList.copyOf(futures);

     */
    @CanIgnoreReturnValue
    @Override
    public Builder<E> addAll(Iterable<? extends E> elements) {
      if (elements instanceof Multiset) {
        Multiset<? extends E> multiset = (Multiset<? extends E>) elements;
        multiset.forEachEntry((e, n) -> contents.add(checkNotNull(e), n));
      } else {
        super.addAll(elements);
      }

      return mapGenerator;
    }
  }

  public static class MapSortedKeySetGenerator<
          K extends @Nullable Object, V extends @Nullable Object>
      extends MapKeySetGenerator<K, V> implements TestSortedSetGenerator<K> {
    private final TestSortedMapGenerator<K, V> delegate;

    public MapSortedKeySetGenerator(

   */
  public static <F extends @Nullable Object, T extends @Nullable Object> Supplier<T> compose(
      Function<? super F, T> function, Supplier<F> supplier) {
    return new SupplierComposition<>(function, supplier);
  }

  private static final class SupplierComposition<
          F extends @Nullable Object, T extends @Nullable Object>
      implements Supplier<T>, Serializable {