id("okhttp.quality-conventions")
  id("okhttp.testing-conventions")
  application
}

application {
  mainClass.set("okhttp3.sample.Crawler")
}

dependencies {
  implementation(projects.okhttp)
  implementation(libs.jsoup)
}

tasks.compileJava {
  options.isWarnings = false

package ioutil

import (
	"io"
)

// Discard is just like io.Discard without the io.ReaderFrom compatible
// implementation which is buggy on NUMA systems, we have to use a simpler
// io.Writer implementation alone avoids also unnecessary buffer copies,
// and as such incurred latencies.
var Discard io.Writer = discard{}

// discard is /dev/null for Golang.
type discard struct{}

     */
    protected IngestFactory getIngestFactory() {
        return ComponentUtil.getIngestFactory();
    }

    /**
     * Processes a result data object for web/file crawling.
     * Default implementation returns the target unchanged.
     *
     * @param target the result data to process
     * @param responseData the response data from crawling
     * @return the processed result data
     */

                addCompilationFrom(sources)
            }

            dependencies {
                implementation(project())
                notForAccessorGeneration {
                    implementation(platform(project(":distributions-dependencies")))
                    implementation(project(":internal-architecture-testing"))
                }
            }

            targets {
                all {

plugins {
  kotlin("jvm")
  id("okhttp.jvm-conventions")
  id("okhttp.quality-conventions")
  id("okhttp.testing-conventions")
}

dependencies {
  implementation(projects.okhttp)
  implementation(libs.square.moshi)

          .build();

  /**
   * type → implementation. Inherently mutable interfaces and abstract classes are mapped to their
   * default implementations and are "new"d upon get().
   */
  private static final ConcurrentMap<Class<?>, Class<?>> implementations = Maps.newConcurrentMap();

  private static <T> void setImplementation(Class<T> type, Class<? extends T> implementation) {

   * containers with a known order other than insertion order must override this method.
   *
   * <p>Note: This default implementation is overkill (but valid) for an unordered container. An
   * equally valid implementation for an unordered container is to throw an exception. The chosen
   * implementation, however, has the advantage of working for insertion-ordered containers, as
   * well.
   */
  @Override

   * containers with a known order other than insertion order must override this method.
   *
   * <p>Note: This default implementation is overkill (but valid) for an unordered container. An
   * equally valid implementation for an unordered container is to throw an exception. The chosen
   * implementation, however, has the advantage of working for insertion-ordered containers, as
   * well.
   */
  @Override

   * containers with a known order other than insertion order must override this method.
   *
   * <p>Note: This default implementation is overkill (but valid) for an unordered container. An
   * equally valid implementation for an unordered container is to throw an exception. The chosen
   * implementation, however, has the advantage of working for insertion-ordered containers, as
   * well.
   */
  @Override

}

description = "Provides a plugin to define the version and name for subproject publications"

group = "gradlebuild"

dependencies {
    api(platform(projects.buildPlatform))

    implementation(projects.basics)

    implementation(buildLibs.gson)