package org.gradle.tooling;

import java.io.Serializable;

/**
 * An action that executes against a Gradle build and produces a result of type {@code T}.
 *
 * <p>You can execute a {@code BuildAction} using the {@link ProjectConnection#action(BuildAction)} method.</p>
 *
 * @param <T> The type of result produced by this action.
 * @since 1.8
 */
public interface BuildAction<T> extends Serializable {
    /**

/**
 * Signifies that the command completed successfully.
 * <p>
 * The value of the result is whatever the command produced on the server.
 * Its meaning depends on the original command.
 * <p>
 * This result type does permit {@code null} values. If it is an error for a certain
 * command to produce a {@code null} value that must be handled externally to this class.
 */
public class Success extends Result<Object> {

import org.gradle.api.internal.tasks.TaskDependencyResolveContext;
import org.gradle.api.internal.tasks.WorkNodeAction;

import javax.annotation.Nullable;

/**
 * Produces a value, potentially based on values produced by tasks or other work nodes.
 */
public interface ValueCalculator<T> extends TaskDependencyContainer {
    /**
     * See {@link WorkNodeAction#usesMutableProjectState()}.
     */

        when:
        signing {
            sign jar, sourcesJar
        }

        then:
        signJar.description == "Signs the archive produced by the 'jar' task."
        signSourcesJar.description == "Signs the archive produced by the 'sourcesJar' task."
    }

    private createJarTaskOutputFile(String... tasksToSimulate) {
        for (def task : tasksToSimulate) {

import org.gradle.internal.component.local.model.LocalComponentGraphResolveState;

import javax.annotation.concurrent.ThreadSafe;

/**
 * A provider of dependency resolution metadata for locally produced components.
 *
 * <p>In general, you should be using {@link LocalComponentRegistry} instead of this type.</p>
 */
@ThreadSafe
public interface LocalComponentProvider {
    /**

import org.gradle.api.internal.artifacts.ivyservice.resolveengine.artifact.ResolvedVariant;
import org.gradle.api.internal.attributes.ImmutableAttributes;

/**
 * Represents a variant which is produced as the result of applying an artifact transform chain
 * to a root producer variant.
 */
public class TransformedVariant implements HasAttributes {
    private final ResolvedVariant root;
    private final VariantDefinition chain;

Tasks runnable from project ':app'
------------------------------------------------------------

...

Publishing tasks
----------------
publish - Publishes all publications produced by this project.
publishToMavenLocal - Publishes all Maven publications produced by this project to the local Maven cache.
----

A new set of publishing tasks are now available called `publish`, and `publishToMavenLocal`.

// 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

int val;

int getVal() {
	return val;

   *   {@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

    }

    /**
     * Returns the compilation outputs produced by the sources that are generating Scaladoc.
     *
     * @return the compilation outputs produced from the sources
     * @since 7.3
     */
    @Internal
    public ConfigurableFileCollection getCompilationOutputs() {
        return compilationOutputs;
    }