String projectId = getId(project);

            MavenProject conflictingProject = projectMap.put(projectId, project);

            if (conflictingProject != null) {
                throw new DuplicateProjectException(
                        projectId,
                        conflictingProject.getFile(),
                        project.getFile(),
                        "Project '" + projectId + "' is duplicated in the reactor");

    private final Map<String, MavenProject> projects;

    private final Map<String, Integer> indices;

    public ProjectIndex(List<MavenProject> projects) {
        this.projects = new HashMap<>(projects.size() * 2);
        this.indices = new HashMap<>(projects.size() * 2);

        for (int i = 0; i < projects.size(); i++) {
            MavenProject project = projects.get(i);

import configurations.SanityCheck
import configurations.SmokeIdeTests
import configurations.SmokeTests
import configurations.TestPerformanceTest
import projects.DEFAULT_FUNCTIONAL_TEST_BUCKET_SIZE
import projects.DEFAULT_LINUX_FUNCTIONAL_TEST_BUCKET_SIZE
import projects.DEFAULT_MACOS_FUNCTIONAL_TEST_BUCKET_SIZE

enum class StageName(
    val stageName: String,
    val description: String,
    val uuid: String,
) {

     * from any repository but are present among the set of specified projects will not cause an exception. Instead,
     * those unresolved artifacts will be returned in the result set, allowing the caller to take special care of
     * artifacts that haven't been build yet.
     *

            throws DuplicateProjectException {
        Map<String, MavenProject> index = new LinkedHashMap<>();
        Map<String, List<File>> collisions = new LinkedHashMap<>();

        for (MavenProject project : projects) {
            String projectId = ArtifactUtils.key(project.getGroupId(), project.getArtifactId(), project.getVersion());

    BuildPlan() {
        this.projects = null;
    }

    public BuildPlan(Map<MavenProject, List<MavenProject>> projects) {
        this.projects = projects;
    }

    public Map<MavenProject, List<MavenProject>> getAllProjects() {
        return projects;
    }

    public Map<String, String> aliases() {
        return aliases;
    }

    public Stream<MavenProject> projects() {

    }

    @Override
    public List<Project> getProjects(List<MavenProject> projects) {
        return projects == null ? null : map(projects, this::getProject);
    }

    @Override
    public Project getProject(MavenProject project) {
        return project != null && project.getBasedir() != null
                ? allProjects.computeIfAbsent(project.getId(), id -> new DefaultProject(this, project))
                : null;
    }

 * under the License.
 */
package org.apache.maven.execution;

import org.apache.maven.project.MavenProject;

/**
 * Instances of this interface retrieve and store data for the --resume / -r feature. This data is used to ensure newer
 * builds of the same project, that have the -r command-line flag, skip successfully built projects during earlier
 * invocations of Maven.
 */
public interface BuildResumptionDataRepository {
    /**

 * the {@code /project/subprojects/subproject} elements of the POM in the aggregator project.
 * Note that the aggregator project is required to have a {@code pom} packaging.</p>
 *
 * <p><dfn>Project inheritance</dfn> defines a parent-child relationship between projects.
 * The <dfn>child project</dfn> inherits all the information from the <dfn>parent project</dfn>
 * POM.</p>
 *
 */

        buildSuccessesByProject.put(getProjectKey(project), new BuildSuccess(project, time));
    }

    public void registerBuildSuccess(MavenProject project, Duration time) {
        buildSuccessesByProject.put(getProjectKey(project), new BuildSuccess(project, time));
    }

    public BuildFailure getBuildFailure(MavenProject project) {