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

import org.codelibs.fess.crawler.Constants;
import org.codelibs.fess.crawler.entity.RequestData;
import org.codelibs.fess.crawler.entity.RequestData.Method;

/**
 * Builder class for creating RequestData objects using a fluent interface.

     * @param value The value of the setting.
     * @return This builder instance.
     */
    public SuggestSettingsBuilder addInitialSettings(final String key, final Object value) {
        initialSettings.put(key, value);
        return this;
    }

    /**
     * Sets the scroll timeout.
     * @param timeout The scroll timeout.
     * @return This builder instance.
     */

          "antlr",
          "base-diagnostics",
          "base-services",
          "build-cache",
          "build-cache-http",
          "build-cache-local",
          "build-cache-spi",
          "build-configuration",
          "build-events",
          "build-init",
          "build-profile",
          "composite-builds",
          "configuration-cache",
          "core",
          "core-api",

    val client =
      OkHttpClient
        .Builder()
        .sslSocketFactory(sslContext.socketFactory, trustManager)
        .build()

    // An example test URL that returns client certificate details.
    val request =
      Request
        .Builder()
        .url("https://prod.idrix.eu/secure/")
        .build()

    client.newCall(request).execute().use { response ->

Guillaume Nodet <******@****.***> 1729859506 +0200

# Build execution model

At the highest level, Gradle's execution model is quite simple:

Below is the protocol in some more detail:

1. The client looks for a compatible idle daemon. If there isn't one, it starts a new daemon.
2. The client connects to the idle daemon and sends it a request to do some work. If the daemon is no longer running, the client starts again.

import org.apache.maven.lifecycle.internal.builder.Builder;

/**
 * <p>
 * A {@link Builder} encapsulates a strategy for building a set of Maven projects. The default strategy in Maven builds
 * the projects serially, but a {@link Builder} can employ any type of concurrency model to build the projects.
 */
@Named("singlethreaded")
@Singleton
public class SingleThreadedBuilder implements Builder {

Yuri Schimke <******@****.***> 1758435742 +0100

Shinsuke Sugaya <******@****.***> 1436049991 +0900

     * @return This builder instance.
     */
    public SuggesterBuilder settings(final SuggestSettings settings) {
        this.settings = settings;
        settingsBuilder = null;
        return this;
    }

    /**
     * Sets the suggest settings builder.
     * @param settingsBuilder The suggest settings builder.
     * @return This builder instance.
     */