* See the License for the specific language governing permissions and
 * limitations under the License.
 */
package okhttp3.internal.connection

import okhttp3.Route

/**
 * A denylist of failed routes to avoid when creating a new connection to a target address. This is
 * used so that OkHttp can learn from its mistakes: if there was a failure attempting to connect to

import static java.util.Arrays.asList;
import static java.util.Collections.singleton;
import static java.util.Comparator.comparing;
import static java.util.Comparator.naturalOrder;
import static java.util.Comparator.reverseOrder;

import com.google.common.annotations.GwtCompatible;
import com.google.common.testing.EqualsTester;
import java.util.Collections;
import java.util.Comparator;
import java.util.Optional;

    public void setMirroredRepositories(List<ArtifactRepository> mirroredRepositories) {
        if (mirroredRepositories != null) {
            this.mirroredRepositories = Collections.unmodifiableList(mirroredRepositories);
        } else {
            this.mirroredRepositories = Collections.emptyList();
        }
    }

    public boolean isBlocked() {
        return blocked;
    }

    public void setBlocked(boolean blocked) {

      assertThat(network.edges()).isEmpty(); // no edges can remain if there's no nodes
      AbstractNetworkTest.validateNetwork(network);

      Collections.shuffle(nodeList, gen);
      for (Integer node : nodeList) {
        assertThat(network.addNode(node)).isTrue();
      }
      Collections.shuffle(edgeList, gen);
      for (Object edge : edgeList) {
        assertThat(
                network.addEdge(

            mergeModelBase(builder, target, source, true, Collections.emptyMap());
        }

        public void mergeBuildBase(BuildBase.Builder builder, BuildBase target, BuildBase source) {
            mergeBuildBase(builder, target, source, true, Collections.emptyMap());
        }

        @Override
        protected void mergePluginContainer_Plugins(

  }

  public TesterRequirements(TesterRequirements tr) {
    this(tr.getPresentFeatures(), tr.getAbsentFeatures());
  }

  public TesterRequirements() {
    this(Collections.<Feature<?>>emptySet(), Collections.<Feature<?>>emptySet());
  }

  public final Set<Feature<?>> getPresentFeatures() {
    return presentFeatures;
  }

  public final Set<Feature<?>> getAbsentFeatures() {

 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.filter;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import org.apache.commons.codec.DecoderException;
import org.apache.commons.codec.net.URLCodec;

  }

  /**
   * Return the route from [connection] if it should be retried, even if the connection itself is
   * unhealthy. The biggest gotcha here is that we shouldn't reuse routes from coalesced
   * connections.
   */
  private fun retryRoute(connection: RealConnection): Route? {
    return connection.withLock {
      when {
        connection.routeFailureCount != 0 -> null

                    newUrlList.add(favoriteLog.getUrl());
                }
                return newUrlList;
            }
            return Collections.<String> emptyList();
        }).orElse(Collections.<String> emptyList());

    }

  fun connectionPreface() {
    this.withLock {
      if (closed) throw IOException("closed")
      if (!client) return // Nothing to write; servers don't send connection headers!
      if (logger.isLoggable(FINE)) {
        logger.fine(format(">> CONNECTION ${CONNECTION_PREFACE.hex()}"))
      }
      sink.write(CONNECTION_PREFACE)
      sink.flush()
    }
  }