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

        Try<T> getResult();

        /**
         * The origin metadata of the result.
         *
         * If a previously produced output was reused in some way, the reused output's origin metadata is returned.
         * If the output was produced in this request, then the current execution's origin metadata is returned.
         */
        Optional<OriginMetadata> getOriginMetadata();
    }

 *
 * A task can depend upon another task's outcome (PASS vs. FAIL), outputs (the files they produce) or both. A verification
 * failure represents the case where a task has a failed outcome, but has still produced valid output files for consumption.
 * Tasks that only depend on the other task's outputs are allowed to execute. Tasks that depend on both the outcome and

        provider.getProducer().visitContentProducerTasks(producer -> {
            if (!producer.getState().getExecuted()) {
                throw new InvalidUserCodeException(
                    String.format("Querying the mapped value of %s before %s has completed is not supported", provider, producer)
                );
            }
        });
    }

    @Override

 * added to the task graph.  For example "clean build" on the command line implies that the user wants
 * to run the clean tasks of each project before the build tasks of each project.  Ordinal nodes ensure
 * this order by tracking the dependencies of destroyers and producers in each group of tasks added to

    def "can exclude certain products from the generated file"() {
        given:
        createDirs("lib1", "lib2", "app")
        settingsFile << "include 'lib1', 'lib2', 'app'"
        buildFile << """
            plugins {
                id 'swiftpm-export'
            }

            afterEvaluate {
                generateSwiftPmManifest.package.get().products.removeAll { p -> p.name == 'app' }
            }

			// by 2 or more characters. We consider nm names that are longer by 1
			// character insignificant to avoid replacing foo with _foo on MacOS (for
			// unknown reasons read2line produces the former and nm produces the
			// latter on MacOS even though both tools are asked to produce mangled
			// names).
			nmName := nm[len(nm)-1].Func
			a2lName := stack[len(stack)-1].Func
			if len(nmName) > len(a2lName)+1 {
				stack[len(stack)-1].Func = nmName

            #include HEADER
        """

        expect:
        resolve() == [header]
    }

    def "resolves macro with value that is token concatenation that produces another macro"() {
        given:
        sourceFile << """
            #define HEADER_NAME "hello.h"
            #define _NAME do not use this

        render implicitDependency {
            consumer('consumer')
            producer('producer')
            at(location)
            includeLink()
        }

        then:
        outputEquals """
Gradle detected a problem with the following location: '${location}'.