if (logger.isDebugEnabled()) {
            logger.debug("Initialize {}", this.getClass().getSimpleName());
        }
        fessConfig = ComponentUtil.getFessConfig();
        cache = CacheBuilder.newBuilder()
                .maximumSize(fessConfig.getSuggestPopularWordCacheSizeAsInteger().longValue())
                .expireAfterWrite(fessConfig.getSuggestPopularWordCacheExpireAsInteger().longValue(), TimeUnit.MINUTES)

  private fun makeClient(
    connectionSpec: ConnectionSpec? = null,
    tlsVersion: TlsVersion? = null,
    cipherSuites: List<CipherSuite>? = null,
  ): OkHttpClient =
    this.client
      .newBuilder()
      .apply {
        if (connectionSpec != null) {
          connectionSpecs(
            listOf(
              ConnectionSpec
                .Builder(connectionSpec)
                .apply {

            return new Builder(getUserProperties(), getSystemProperties(), getStartTime(), getTopDirectory(), null);
        }
    }

    /**
     * Returns new builder from scratch.
     */
    static Builder newBuilder() {
        return new Builder().withStartTime(MonotonicClock.now());
    }

    class Builder {
        private Map<String, String> userProperties;
        private Map<String, String> systemProperties;

                .getUserPrincipalLookupService()
                .lookupPrincipalByName(getUsername());
        ImmutableList<AclEntry> acl =
            ImmutableList.of(
                AclEntry.newBuilder()
                    .setType(ALLOW)
                    .setPrincipal(user)
                    .setPermissions(EnumSet.allOf(AclEntryPermission.class))
                    .setFlags(DIRECTORY_INHERIT, FILE_INHERIT)

     * @param type The filter type.
     * @return The created filter cache.
     */
    protected LoadingCache<String, List<Pattern>> createFilterCache(final String type) {
        return CacheBuilder.newBuilder()//
                .expireAfterWrite(filterCacheExpireAfterWrite, TimeUnit.SECONDS)//
                .build(new CacheLoader<String, List<Pattern>>() {

                    /**

      result += namesAndValues[i].length.toLong()
    }

    return result
  }

  override operator fun iterator(): Iterator<Pair<String, String>> = commonIterator()

  fun newBuilder(): Builder = commonNewBuilder()

  /**
   * Returns true if `other` is a `Headers` object with the same headers, with the same casing, in

      @Nullable DurationSpec refresh,
      @Nullable Strength keyStrength,
      @Nullable Strength valueStrength) {

    CacheBuilder<Object, Object> builder = CacheBuilder.newBuilder();
    if (concurrencyLevel != null) {
      builder.concurrencyLevel(concurrencyLevel);
    }
    if (initialCapacity != null) {
      builder.initialCapacity(initialCapacity);
    }

  }

  @Test
  fun configureClientDefault() {
    val request =
      Request
        .Builder()
        .url(server.url("/"))
        .build()
    val timeoutClient =
      client
        .newBuilder()
        .callTimeout(Duration.ofMillis(456))
        .build()
    val call = timeoutClient.newCall(request)
    assertThat(call.timeout().timeoutNanos())
      .isEqualTo(TimeUnit.MILLISECONDS.toNanos(456))
  }

	public static final fun get (Ljava/net/URL;)Lokhttp3/HttpUrl;
	public fun hashCode ()I
	public final fun host ()Ljava/lang/String;
	public final fun isHttps ()Z
	public final fun newBuilder ()Lokhttp3/HttpUrl$Builder;
	public final fun newBuilder (Ljava/lang/String;)Lokhttp3/HttpUrl$Builder;
	public static final fun parse (Ljava/lang/String;)Lokhttp3/HttpUrl;
	public final fun password ()Ljava/lang/String;

      return
    }

    val webSocketClient =
      client
        .newBuilder()
        .eventListener(EventListener.NONE)
        .protocols(ONLY_HTTP1)
        .build()
    val request =
      originalRequest
        .newBuilder()
        .header("Upgrade", "websocket")
        .header("Connection", "Upgrade")
        .header("Sec-WebSocket-Key", key)