* all super-classes, that are annotated with {@code @Subscribe}. The cache is shared across all
   * instances of this class; this greatly improves performance if multiple EventBus instances are
   * created and objects of the same class are registered on all of them.
   */
  private static final LoadingCache<Class<?>, ImmutableList<Method>> subscriberMethodsCache =

   * {@linkplain Object#equals equal} to the original, nor is it required to return even an object
   * of the same class. For example, if sublists of {@code MyList} instances were serializable,
   * those sublists might implement a private {@code MySubList} type but serialize as a plain {@code
   * MyList} to save space. So long as {@code MyList} has all the public supertypes of {@code

import java.util.NoSuchElementException;
import java.util.SortedSet;
import org.jspecify.annotations.Nullable;

/**
 * Provides static utility methods for creating and working with {@link SortedMultiset} instances.
 *
 * @author Louis Wasserman
 */
@GwtCompatible
final class SortedMultisets {
  private SortedMultisets() {}

  /** A skeleton implementation for {@link SortedMultiset#elementSet}. */

import java.util.EnumSet;
import java.util.HashMap;
import java.util.Map;
import java.util.WeakHashMap;
import org.jspecify.annotations.Nullable;

/**
 * Utility methods for working with {@link Enum} instances.
 *
 * @author Steve McKay
 * @since 9.0
 */
@GwtIncompatible
@J2ktIncompatible
public final class Enums {

  private Enums() {}

  /**

 * RegularImmutableBiMap}, which don't have to recopy the entries created by their {@code Builder}
 * implementations.
 *
 * <p>This base implementation has no key or value pointers, so instances of ImmutableMapEntry (but
 * not its subclasses) can be reused when copied from one ImmutableMap to another.
 *
 * @author Louis Wasserman
 */
@GwtIncompatible // unnecessary

 * is not an open, stateful stream for input that can be read and closed. Instead, it is an
 * immutable <i>supplier</i> of {@code InputStream} instances.
 *
 * <p>{@code ByteSource} provides two kinds of methods:
 *
 * <ul>
 *   <li><b>Methods that return a stream:</b> These methods should return a <i>new</i>, independent

   * through java serialization. However, floating point rounding errors mean that it may be false
   * for some instances where the statistics are mathematically equal, including instances
   * constructed from the same values in a different order... or (in the general case) even in the
   * same order. (It is guaranteed to return true for instances constructed from the same values in

        return getTraverser(url, null, rootDir);
    }

    /**
     * Returns an array of {@link Traverser} instances that handle collections of classes or resources based on the specified root package.
     *
     * @param rootPackage
     *            The root package.
     * @return An array of {@link Traverser} instances that handle collections of resources based on the specified root package.
     */

   * identically to this equivalence.
   *
   * <p><b>Warning: do not depend</b> on the behavior of this method.
   *
   * <p>Historically, {@code Equivalence} instances in this library have implemented this method to
   * recognize certain cases where distinct {@code Equivalence} instances would in fact behave
   * identically. However, as code migrates to {@code java.util.function}, that behavior will
   * disappear. It is best not to depend on it.
   */

      ListenableFuture<? extends V>... futures) {
    ListenableFuture<List<@Nullable V>> nullable =
        new ListFuture<V>(ImmutableList.copyOf(futures), true);
    // allAsList ensures that it fills the output list with V instances.
    @SuppressWarnings("nullness")
    ListenableFuture<List<V>> nonNull = nullable;
    return nonNull;
  }

  /**