.withValueStrengths(ImmutableSet.of(STRONG, Strength.WEAK, Strength.SOFT));
  }

  private Iterable<LoadingCache<Key, String>> caches() {
    CacheBuilderFactory factory = factoryWithAllKeyStrengths();
    return Iterables.transform(
        factory.buildAllPermutations(),
        new Function<CacheBuilder<Object, Object>, LoadingCache<Key, String>>() {
          @Override

    return new NullRemovalListener<>();
  }

  /** Type-inferring factory method for creating a {@link QueuingRemovalListener}. */
  @GwtIncompatible // ConcurrentLinkedQueue
  static <K, V> QueuingRemovalListener<K, V> queuingRemovalListener() {
    return new QueuingRemovalListener<>();
  }

  /** Type-inferring factory method for creating a {@link CountingRemovalListener}. */

    val request = Request(server.url("/"))
    val response = client.newCall(request).execute()
    response.body.close()

    // This client shares a connection pool but has a different SSL socket factory.
    val handshakeCertificates2 = HandshakeCertificates.Builder().build()
    val anotherClient =
      client
        .newBuilder()
        .sslSocketFactory(
          handshakeCertificates2.sslSocketFactory(),

        if (crawlerClientFactory != null) {
            return crawlerClientFactory;
        }
        final CrawlerClientFactory factory = creator.get();

        final Map<String, String> paramMap = getHandlerParameterMap();

        final Map<String, Object> factoryParamMap = new HashMap<>();
        factory.setInitParameterMap(factoryParamMap);

        // parameters

});

// Configure content extraction
container.singleton("tikaExtractor", TikaExtractor.class);
container.singleton("extractorFactory", ExtractorFactory.class, factory -> {
    factory.addExtractor("text/html", container.getComponent("tikaExtractor"));
    factory.addExtractor("application/pdf", container.getComponent("tikaExtractor"));
});

Crawler crawler = container.getComponent("crawler");
crawler.addUrl("https://example.com");

    public void parse(final InputSource is) {
        try {
            final SAXParserFactory factory = SAXParserFactory.newInstance();
            factory.setFeature(org.codelibs.fess.crawler.Constants.FEATURE_SECURE_PROCESSING, true);
            factory.setFeature(org.codelibs.fess.crawler.Constants.FEATURE_EXTERNAL_GENERAL_ENTITIES, false);
            factory.setFeature(org.codelibs.fess.crawler.Constants.FEATURE_EXTERNAL_PARAMETER_ENTITIES, false);

    })
    .build()
```

SAM conversion impacts these APIs:

 * Authenticator
 * Dispatcher.setIdleCallback(Runnable)
 * Dns
 * EventListener.Factory
 * HttpLoggingInterceptor.Logger
 * LoggingEventListener.Factory
 * OkHttpClient.Builder.hostnameVerifier(HostnameVerifier)

JetBrains [is working on][kotlin_sams] SAM conversions of Kotlin interfaces. Expect it in a future

        this.eventListenerFactory = eventListener.asFactory()
      }

    /**
     * Configure a factory to provide per-call scoped listeners that will receive analytic events
     * for this client.
     *
     * @see EventListener for semantics and restrictions on listener implementations.
     */
    fun eventListenerFactory(eventListenerFactory: EventListener.Factory) =
      apply {

 * either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */
package org.codelibs.core.log;

/**
 * Factory for creating logger adapters.
 *
 * @author koichik
 */
interface LoggerAdapterFactory {

    LoggerAdapter getLoggerAdapter(Class<?> clazz);

    void releaseAll();

        .connectionSpecs(Collections.singletonList(spec))
        .sslSocketFactory(customSslSocketFactory, trustManager)
        .build();
  }

  /**
   * Returns the VM's default SSL socket factory, using {@code trustManager} for trusted root
   * certificates.
   */
  private SSLSocketFactory defaultSslSocketFactory(X509TrustManager trustManager)
      throws NoSuchAlgorithmException, KeyManagementException {