}

  private static Set<Feature<?>> computeInverseFeatures(Set<Feature<?>> mapFeatures) {
    Set<Feature<?>> inverseFeatures = new HashSet<>(mapFeatures);

    boolean nullKeys = inverseFeatures.remove(MapFeature.ALLOWS_NULL_KEYS);
    boolean nullValues = inverseFeatures.remove(MapFeature.ALLOWS_NULL_VALUES);

    if (nullKeys) {
      inverseFeatures.add(MapFeature.ALLOWS_NULL_VALUES);
    }
    if (nullValues) {

   *   <li>and this method returns true for the {@link InvocationHandler} of {@code argument}
   * </ul>
   *
   * <p>Subclasses can override this method to provide custom equality.
   */
  @Override
  public boolean equals(@CheckForNull Object obj) {
    return super.equals(obj);
  }

  /**
   * By default delegates to {@link Object#hashCode}. The dynamic proxies' {@code hashCode()} will

  @Target(ElementType.METHOD)
  @interface TestSubtype {
    /** Suppresses the assertion on {@link TypeToken#getSubtype}. */
    boolean suppressGetSubtype() default false;

    /** Suppresses the assertion on {@link TypeToken#getSupertype}. */
    boolean suppressGetSupertype() default false;
  }

  private @Nullable Method method = null;

                            "paid": {"title": "Paid", "type": "boolean"},
                        },
                    },
                    "InvoiceEventReceived": {
                        "title": "InvoiceEventReceived",
                        "required": ["ok"],
                        "type": "object",
                        "properties": {"ok": {"title": "Ok", "type": "boolean"}},
                    },

   */
  @Override
  boolean isDirected();

  /**
   * Returns true if this graph allows self-loops (edges that connect a node to itself). Attempting
   * to add a self-loop to a graph that does not allow them will throw an {@link
   * IllegalArgumentException}.
   */
  @Override
  boolean allowsSelfLoops();

 * limitations under the License.
 */
@file:Suppress("ktlint:standard:filename")

package okhttp3.internal

import okhttp3.Challenge

fun Challenge.commonEquals(other: Any?): Boolean {
  return other is Challenge &&
    other.scheme == scheme &&
    other.authParams == authParams
}

fun Challenge.commonHashCode(): Int {
  var result = 29
  result = 31 * result + scheme.hashCode()

        initialize();
    }

    @Override
    public <T> T getComponent(final String name) {
        return SingletonLaContainerFactory.getContainer().getComponent(name);
    }

    @Override
    public boolean available() {
        return SingletonLaContainerFactory.hasContainer();
    }

    @Override
    public void destroy() {
        SingletonLaContainerFactory.destroy();
    }

    /** クラスをキーとするロガー のマップ */
    protected static final Map<Class<?>, Logger> loggers = newHashMap();

    /** 初期化済みを示すフラグ */
    private static boolean initialized;

    /** ロガーアダプタ */
    private final LoggerAdapter log;

    /**
     * {@link Logger}を返します。
     *
     * @param clazz
     *            ロガーのカテゴリとなるクラス。{@literal null}であってはいけません

  override fun contentType(): MediaType? = null

  override fun writeTo(sink: BufferedSink) {
    requestBodySinks.add(sink)
  }

  override fun isDuplex(): Boolean = true

  @Throws(InterruptedException::class)
  fun takeSink(): BufferedSink {
    return requestBodySinks.poll(5, SECONDS) ?: throw AssertionError("no sink to take")
  }

  fun assertNoMoreSinks() {

  private final String s;

  public BaseComparable(String s) {
    this.s = s;
  }

  @Override
  public int hashCode() { // delegate to 's'
    return s.hashCode();
  }

  @Override
  public boolean equals(@Nullable Object other) {
    if (other == null) {
      return false;
    } else if (other instanceof BaseComparable) {
      return s.equals(((BaseComparable) other).s);
    } else {
      return false;
    }