* See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.platform.base;

import org.gradle.api.Incubating;

/**
 * A binary produced from a `{@link org.gradle.platform.base.LibrarySpec}`.
 */
@Incubating
public interface LibraryBinarySpec extends BinarySpec {
    /**
     * The library that this binary belongs to.
     */

link the result into a binary file. For an executable component, Gradle can produce executable binary files. For a library component, Gradle can produce both static and shared library binary files. For example, when you define a library called `helloworld` and build on Linux, Gradle will, by default, produce `libhelloworld.so` and `libhelloworld.a` binaries.

In many cases, more than one binary can be produced for a component. These binaries may vary based on the tool chain used to build,...

 *
 * This is useful for listing what a project produces in terms of variants and
 * what artifacts are attached to each variant.
 *
 * Variants, in this context, must be understood as "things produced by a project
 * which can safely be consumed by another project".
 *
 * @since 6.0
 */
@DisableCachingByDefault(because = "Produces only non-cacheable console output by examining configurations at execution time")

// The attribute that marks function calls produced by the encapsulate
// subgraphs pass and that should in turn be compiled via XlaLaunch operators.
extern const char* const kXlaCompiledKernelAttr;

// Does `node` have the kXlaCompiledKernelAttr attribute?
bool IsXlaCompiledKernel(const Node& node);

// Functions produced by the EncapsulateSubgraphs pass have their arguments in
// the order:

import org.gradle.api.file.FileCollection;

/**
 * Represents a component with output files.
 *
 * @since 4.5
 */
public interface ComponentWithOutputs extends SoftwareComponent {
    /**
     * Returns the outputs produced for this component.
     */
    FileCollection getOutputs();

   *   {@code List<ListenableFuture<T>> futures = (List) executor.invokeAll(tasks);}
   * </pre>
   *
   * @return A list of {@code ListenableFuture} instances representing the tasks, in the same
   *     sequential order as produced by the iterator for the given task list, each of which has
   *     completed.
   * @throws RejectedExecutionException {@inheritDoc}
   * @throws NullPointerException if any task is null
   */
  @Override

 */
public interface ClasspathElementTransformFactory {
    /**
     * Updates jar/directory content hash to account for the transform produced by this factory.
     *
     * @param hasher the hasher to modify
     */
    void applyConfigurationTo(Hasher hasher);

    /**
     * Returns the transformation to be applied to the given jar/directory.
     *

----
java {
    withJavadocJar()
}
----

.build.gradle
[source.multi-language-sample,groovy]
----
java {
    withJavadocJar()
}
----



The additional JAR will be produced as part of the `assemble` or `build` lifecycle tasks and will be part of the publication.

import org.gradle.tooling.model.GradleModuleVersion;
import org.gradle.tooling.model.ProjectIdentifier;
import org.gradle.tooling.model.ProjectModel;

/**
 * Represents some publication produced by a Gradle project, typically to a Maven or Ivy repository.
 *
 * @since 1.12
 */
public interface GradlePublication extends ProjectModel {

    /**

// Copyright 2015 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

// This program produced false race reports when run under the C/C++
// ThreadSanitizer, as it did not understand the synchronization in
// the Go code.

/*
#cgo CFLAGS: -fsanitize=thread
#cgo LDFLAGS: -fsanitize=thread

extern void GoRun(void);