import java.io.File;

/**
 * Identifies a Gradle build.
 * <p>
 *     A Gradle Build is a collection of one or more projects.
 * </p>
 *
 * @since 2.13
 */
public interface BuildIdentifier extends Model {
    /**
     * The root directory of this build
     *
     * @return the root dir, never null
     * @since 3.3
     */
    File getRootDir();

package org.gradle.api.artifacts.component;

/**
 * Identifies a Gradle build. The identifier is unique within a Gradle invocation, so for example, each included build will have a different identifier.
 */
public interface BuildIdentifier {

    /**
     * Absolute build path of the build within the Gradle invocation.
     *
     * @since 8.2
     */
    String getBuildPath();

    /**
     * The name of the build.
     *

    }

    public BuildServiceDetails(BuildIdentifier buildIdentifier, String name, Class<T> implementationType) {
        this.buildIdentifier = buildIdentifier;
        this.name = name;
        this.implementationType = implementationType;
        this.parameters = null;
        this.maxUsages = -1;
        this.resolved = false;
    }

    public BuildIdentifier getBuildIdentifier() {
        return buildIdentifier;

        this.buildIdentifier = buildIdentifier;
        this.projectPath = projectPath;
    }

    @Override
    public String getDisplayName() {
        if (displayName == null) {
            displayName = "project " + identityPath.getPath();
        }
        return displayName;
    }

    @Override
    public BuildIdentifier getBuild() {
        return buildIdentifier;
    }

    @Override

import org.gradle.api.artifacts.component.BuildIdentifier;
import org.gradle.api.internal.TaskInternal;

public interface TaskIdentifier {
    BuildIdentifier getBuildIdentifier();

    String getTaskPath();

    interface TaskBasedTaskIdentifier extends TaskIdentifier {
        TaskInternal getTask();
    }

    static TaskBasedTaskIdentifier of(BuildIdentifier buildIdentifier, TaskInternal task) {

    /**
     * Locates an included build by {@link BuildIdentifier}, if present. Fails if not an included build.
     */
    IncludedBuildState getIncludedBuild(BuildIdentifier buildIdentifier) throws IllegalArgumentException;

    /**
     * Locates a build. Fails if not present.
     */
    BuildState getBuild(BuildIdentifier buildIdentifier) throws IllegalArgumentException;

    /**

public class RootOfNestedBuildTree extends AbstractBuildState implements NestedRootBuild {
    private final BuildIdentifier buildIdentifier;
    private final Path identityPath;
    private final BuildTreeLifecycleController buildTreeLifecycleController;

    public RootOfNestedBuildTree(
        BuildDefinition buildDefinition,
        BuildIdentifier buildIdentifier,
        Path identityPath,
        BuildState owner,
        BuildTreeState buildTree

            case ROOT_PROJECT: {
                BuildIdentifier buildIdentifier = buildIdentifierSerializer.read(decoder);
                String projectName = decoder.readString();
                return new DefaultProjectComponentIdentifier(buildIdentifier, Path.ROOT, Path.ROOT, projectName);
            }
            case ROOT_BUILD_PROJECT: {
                BuildIdentifier buildIdentifier = buildIdentifierSerializer.read(decoder);

        when:
        GradleBuild rootBuild = loadToolingModel(GradleBuild)

        then:
        rootBuild.buildIdentifier.rootDir == rootDir
        rootBuild.rootProject.name == "root"
        rootBuild.includedBuilds.size() == 1

        def buildB = rootBuild.includedBuilds[0]
        buildB.buildIdentifier.rootDir == buildBDir
        buildB.rootProject.name == "buildB"
        buildB.projects.size() == 4

        BuildState buildState = findBuild(buildIdentifier);
        if (buildState == null) {
            throw new IllegalArgumentException("Could not find " + buildIdentifier);
        }
        return buildState;
    }

    @Override
    public BuildState findBuild(BuildIdentifier buildIdentifier) {
        return buildsByIdentifier.get(buildIdentifier);
    }