import java.util.Map;
import org.jspecify.annotations.Nullable;

/**
 * An object representing the differences between two maps.
 *
 * @author Kevin Bourrillion
 * @since 2.0
 */
@DoNotMock("Use Maps.difference")
@GwtCompatible
public interface MapDifference<K extends @Nullable Object, V extends @Nullable Object> {
  /**

 * @param <V> the type of the mapped values
 * @since 7.0
 */
@DoNotMock("Use ImmutableTable, HashBasedTable, or another implementation")
@GwtCompatible
public interface Table<
    R extends @Nullable Object, C extends @Nullable Object, V extends @Nullable Object> {
  // TODO(jlevy): Consider adding methods similar to ConcurrentMap methods.

  // Accessors

  /**

   */
  public static <E extends @Nullable Object> List<E> asList(
      @ParametricNullness E first, @ParametricNullness E second, E[] rest) {
    return new TwoPlusArrayList<>(first, second, rest);
  }

  /**
   * @see Lists#asList(Object, Object[])
   */
  private static final class OnePlusArrayList<E extends @Nullable Object> extends AbstractList<E>
      implements Serializable, RandomAccess {

            DefaultDependencyResolverRequest(
                    @Nonnull Session session,
                    @Nullable RequestTrace trace,
                    @Nonnull RequestType requestType,
                    @Nullable Project project,
                    @Nullable Artifact rootArtifact,
                    @Nullable DependencyCoordinates root,
                    @Nonnull Collection<DependencyCoordinates> dependencies,

  private final @Nullable CacheLoader<? super K, V> loader;
  private final @Nullable RemovalListener<? super K, ? super V> removalListener;
  private final StatsCounter statsCounter;
  private final Ticker ticker;
  private final long expireAfterWrite;
  private final long expireAfterAccess;

  LocalCache(
      CacheBuilder<? super K, ? super V> builder, @Nullable CacheLoader<? super K, V> loader) {

  abstract <R> @Nullable R dummyReturnValue(TypeToken<R> returnType);

  private final class DummyHandler extends AbstractInvocationHandler implements Serializable {
    private final TypeToken<?> interfaceType;

    DummyHandler(TypeToken<?> interfaceType) {
      this.interfaceType = interfaceType;
    }

    @Override
    protected @Nullable Object handleInvocation(

   * href="http://gee.cs.oswego.edu/dl/html/StreamParallelGuidance.html">efficiently splittable</a>.
   * This may harm parallel performance.
   */
  @Beta
  public static <A extends @Nullable Object, B extends @Nullable Object, R extends @Nullable Object>
      Stream<R> zip(
          Stream<A> streamA, Stream<B> streamB, BiFunction<? super A, ? super B, R> function) {
    checkNotNull(streamA);
    checkNotNull(streamB);

  @Override
  public <T extends B> @Nullable T putInstance(
      Class<@NonNull T> type, @ParametricNullness T value) {
    return cast(type, put(type, value));
  }

  @Override
  public <T extends @NonNull B> @Nullable T getInstance(Class<T> type) {
    return cast(type, get(type));
  }

  @CanIgnoreReturnValue
  private static <T> @Nullable T cast(Class<T> type, @Nullable Object value) {

  @SuppressWarnings({"unchecked", "nullness"})
  static int unsafeCompare(
      @Nullable Comparator<?> comparator, @Nullable Object o1, @Nullable Object o2) {
    if (comparator == null) {
      return ((Comparable<@Nullable Object>) o1).compareTo(o2);
    } else {
      return ((Comparator<@Nullable Object>) comparator).compare(o1, o2);
    }
  }

  /**

  /**
   * Returns the entry of the first element in this multiset, or {@code null} if this multiset is
   * empty.
   */
  @Nullable Entry<E> firstEntry();

  /**
   * Returns the entry of the last element in this multiset, or {@code null} if this multiset is
   * empty.
   */
  @Nullable Entry<E> lastEntry();

  /**
   * Returns and removes the entry associated with the lowest element in this multiset, or returns