super(singletonMap(checkNotNull(key), checkNotNull(value)));
    this.singleKey = key;
    this.singleValue = value;
  }

  private SingletonImmutableBiMap(K key, V value, SingletonImmutableBiMap<V, K> inverse) {
    super(singletonMap(checkNotNull(key), checkNotNull(value)));
    this.singleKey = key;
    this.singleValue = value;
    this.inverse = inverse;
  }

  @Override
  public ImmutableBiMap<V, K> inverse() {

    public BaseObject(Object delegate, BaseObject parent) {
        this.delegate = requireNonNull(delegate, "delegate cannot be null");
        this.childrenTracking = parent != null ? parent::replace : null;
    }

    public BaseObject(Object delegate, ChildrenTracking parent) {
        this.delegate = requireNonNull(delegate, "delegate cannot be null");
        this.childrenTracking = parent;
    }

    public Object getDelegate() {

   *
   * <p>This class needs to write deserialized data into fields that are {@code final transient}.
   * Such writes will become impossible to perform in {@link #readObject} after JEP 500. Instead, we
   * must create a new instance with the desired field values, stash it in this field, and then
   * instruct Java serialization to use it instead of the originally created object.
   *
   * <p>We have chosen this approach over at least two alternatives:

    public DefaultRepositoryRequest setOffline(boolean offline) {
        this.offline = offline;

        return this;
    }

    @Override
    public boolean isForceUpdate() {
        return forceUpdate;
    }

    @Override
    public DefaultRepositoryRequest setForceUpdate(boolean forceUpdate) {
        this.forceUpdate = forceUpdate;

        return this;
    }

    @Override

 * com.google.common.base.FinalizableReference}.
 *
 * <p>While this class is public, we consider it to be *internal* and not part of our published API.
 * It is public so we can access it reflectively across class loaders in secure environments.
 *
 * <p>This class can't depend on other Guava code. If we were to load this class in the same class
 * loader as the rest of Guava, this thread would keep an indirect strong reference to the class

        this.containingType = containingType;
        this.propertyName = propertyName;
        this.methodName = methodName;
        this.methodDescriptor = methodDescriptor;
        this.replacedAccessors = ImmutableList.copyOf(replacedAccessors);
    }

    public String getContainingType() {

 *       prevent its use, because this would also rule out all ungenerified (pre-JDK1.5) data types.
 *       <b>This may change in the future.</b>
 * </ul>
 *
 * <h3>Other notes</h3>
 *
 * <ul>
 *   <li>All ranges are shallow-immutable.
 *   <li>Instances of this type are obtained using the static factory methods in this class.

 * Copyright (C) 2000  "Michael B. Allen" <jcifs at samba dot org>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,

 * Handles basic types that always use the same tag. This supports optional types and may set a type
 * hint for further adapters to process.
 *
 * Types like ANY and CHOICE that don't have a consistent tag cannot use this.
 */
internal data class BasicDerAdapter<T>(
  private val name: String,
  /** The tag class this adapter expects, or -1 to match any tag class. */
  val tagClass: Int,
  /** The tag this adapter expects, or -1 to match any tag. */

   * endpoints}) if one is not already present.
   *
   * <p>If this graph is directed, {@code endpoints} must be ordered and the added edge will be
   * directed; if it is undirected, the added edge will be undirected.
   *
   * <p>If this graph is directed, {@code endpoints} must be ordered.
   *
   * <p>If either or both endpoints are not already present in this graph, this method will silently