@CanIgnoreReturnValue
    @Override
    public Builder<K, V> orderKeysBy(Comparator<? super K> keyComparator) {
      super.orderKeysBy(keyComparator);
      return this;
    }

    /**
     * Specifies the ordering of the generated multimap's values for each key.
     *
     * <p>If this method is called, the sets returned by the {@code get()} method of the generated

public class WebApiRequest extends HttpServletRequestWrapper {
    /**
     * The custom servlet path for this web API request.
     */
    protected String servletPath;

    /**
     * Constructs a WebApiRequest with the specified request and servlet path.
     *
     * @param request The original HTTP servlet request
     * @param servletPath The custom servlet path for this web API request
     */

    /** The username extracted from SPNEGO authentication. */
    private final String username;

    /**
     * Constructs a new SpnegoCredential with the specified username.
     *
     * @param username The username obtained from SPNEGO authentication
     */
    public SpnegoCredential(final String username) {
        this.username = username;
    }

    /**

/**
 * Provides the super POM that all models implicitly inherit from.
 *
 * @since 4.0.0
 */
@Experimental
public interface SuperPomProvider extends Service {

    /**
     * Gets the super POM for the specified model version.
     *
     * @param version The model version to retrieve the super POM for (e.g. "4.0.0"), must not be {@code null}.
     * @return The super POM, never {@code null}.

              }
            };
          }
        };
    callAllPublicMethods(new TypeToken<Set<Entry<String, Boolean>>>() {}, forward.entrySet());

    // These are the methods specified by StandardEntrySet
    verify(map, atLeast(0)).clear();
    verify(map, atLeast(0)).containsKey(any());
    verify(map, atLeast(0)).get(any());
    verify(map, atLeast(0)).isEmpty();

On startup all remote servers must be specified.
From that individual connections will be spawned to each remote server,
or incoming requests will be hooked up to the appropriate connection.

To get a connection to a specific server, use `Manager.Connection(host)` to get a connection to the specified host.
From this connection individual requests can be made.

 *
 * <p>This class uses (possibly repeated) invocations of {@link java.lang.System#gc()} to cause
 * finalization to happen. However, a call to {@code System.gc()} is specified to be no more than a
 * hint, so this technique may fail at the whim of the JDK implementation, for example if a user
 * specified the JVM flag {@code -XX:+DisableExplicitGC}. But in practice, it works very well for
 * ordinary tests.
 *

            }
        } catch (final Exception e) {
            logger.warn("Failed to get active instances.", e);
        }
        return instances;
    }

    /**
     * Checks whether the specified instance is currently active.
     *
     * @param targetInstanceId the instance ID to check.
     * @return {@code true} if the instance is active.
     */

/** Utility method to parse the system class path. */
@NullUnmarked
@GwtIncompatible
@J2ktIncompatible
final class ClassPathUtil {
  private ClassPathUtil() {}

  /**
   * Returns the URLs in the class path specified by the {@code java.class.path} {@linkplain
   * System#getProperty system property}.
   */
  // TODO(b/65488446): Make this a public API.
  static URL[] parseJavaClassPath() {

 */
final class StandardMutableGraph<N> extends ForwardingGraph<N> implements MutableGraph<N> {
  private final MutableValueGraph<N, Presence> backingValueGraph;

  /** Constructs a {@link MutableGraph} with the properties specified in {@code builder}. */
  StandardMutableGraph(AbstractGraphBuilder<? super N> builder) {
    this.backingValueGraph = new StandardMutableValueGraph<>(builder);
  }

  @Override
  BaseGraph<N> delegate() {