this.project = project;
        this.executionPlan = executionPlan;
        this.cause = cause;
    }

    public MavenSession getSession() {
        return session;
    }

    public MavenProject getProject() {
        return project;
    }

    public List<MojoExecution> getExecutionPlan() {
        return executionPlan;
    }

    public Throwable getCause() {
        return cause;
    }

        for (Iterator<ProjectSegment> it = projectBuilds.iterator(); it.hasNext(); ) {
            ProjectSegment projectBuild = it.next();

            logger.debug("Project: " + projectBuild.getProject().getId());
            logger.debug("Tasks:   " + projectBuild.getTaskSegment().getTasks());
            logger.debug("Style:   " + (projectBuild.getTaskSegment().isAggregating() ? "Aggregating" : "Regular"));

     */
    private final ConcurrentMap<String, ConcurrentMap<String, ConcurrentMap<String, Object>>>
            pluginContextsByProjectAndPluginKey = new ConcurrentHashMap<>();

    public void setProjects(List<MavenProject> projects) {
        if (!projects.isEmpty()) {
            MavenProject first = projects.get(0);
            this.currentProject = ThreadLocal.withInitial(() -> first);

            MavenProject project,
            Throwable cause) {
        this(createMessage(messageBuilderFactory, execution, project, cause), execution, project, cause);
    }

    public MavenProject getProject() {
        return project;
    }

    private static String createMessage(
            MessageBuilderFactory messageBuilderFactory,
            MojoExecution execution,
            MavenProject project,

                try {
                    lifecycleModuleBuilder.buildProject(
                            session, reactorContext, projectBuild.getProject(), taskSegment);
                    if (reactorBuildStatus.isHalted()) {
                        break;
                    }
                } catch (Exception e) {

import java.util.Collection;
import java.util.function.Consumer;
import java.util.function.Predicate;

public class PomValidationTask extends PrecommitTask {

    private final RegularFileProperty pomFile = getProject().getObjects().fileProperty();

    private boolean foundError;

    @InputFile
    public RegularFileProperty getPomFile() {
        return pomFile;
    }

    @TaskAction

        // so we cannot use session.getProject(p) for forked projects
        // which are temporary clones
        return Optional.ofNullable(getMavenProject(project).getExecutionProject())
                .map(p -> new DefaultProject(session, p));
    }

    private MavenProject getMavenProject(Project project) {
        return ((DefaultProject) project).getProject();
    }

        this.markerFile = objectFactory.fileProperty();
        this.dockerContext = objectFactory.directoryProperty();
        this.buildArgs = objectFactory.mapProperty(String.class, String.class);

        this.markerFile.set(getProject().getLayout().getBuildDirectory().file("markers/" + this.getName() + ".marker"));
    }

    @TaskAction
    public void build() {
        workerExecutor.noIsolation().submit(DockerBuildAction.class, params -> {

        this.wallTime = wallTime;
    }

    /**
     * Gets the project being summarized.
     *
     * @return The project being summarized, never {@code null}.
     */
    public MavenProject getProject() {
        return project;
    }

    /**
     * Gets the wall time of the project in milliseconds.
     *
     * @return The wall time of the project in milliseconds.
     */
    public long getTime() {

    enum RequestType {
        COLLECT,
        FLATTEN,
        RESOLVE
    }

    @Nonnull
    RequestType getRequestType();

    @Nonnull
    Optional<Project> getProject();

    @Nonnull
    Optional<Artifact> getRootArtifact();

    @Nonnull
    Optional<DependencyCoordinates> getRoot();

    @Nonnull
    Collection<DependencyCoordinates> getDependencies();