for (int index = 0; index < sorted.size(); index++) {
            MavenProject project = sorted.get(index);
            String id = ProjectSorter.getId(project);
            this.projects.put(id, project);
            this.order.put(project, index);
        }
    }

    /**
     * @since 3.5.0
     */
    public List<MavenProject> getAllProjects() {
        return this.allProjects;
    }

        Map<String, ExecutionPlanItem> lastInExistingPhases = new HashMap<>();
        for (ExecutionPlanItem executionPlanItem : getExecutionPlanItems()) {
            lastInExistingPhases.put(executionPlanItem.getLifecyclePhase(), executionPlanItem);
        }

        ExecutionPlanItem lastSeenExecutionPlanItem = null;

        for (String phase : totalPhaseSet) {

            for (String phase : lifecycle.getPhases()) {
                // The first definition wins.
                if (!phaseToLifecycleMap.containsKey(phase)) {
                    phaseToLifecycleMap.put(phase, lifecycle);
                } else if (logger.isWarnEnabled()) {
                    Lifecycle original = phaseToLifecycleMap.get(phase);
                    logger.warn(

        Map<String, Artifact> artifactMap = new LinkedHashMap<>();

        if (artifacts != null) {
            for (Artifact artifact : artifacts) {
                artifactMap.put(versionlessKey(artifact), artifact);
            }
        }

        return artifactMap;
    }

    public static Artifact copyArtifactSafe(Artifact artifact) {

        final Lock acquiredAggregatorLock;
        final OwnerReentrantLock acquiredProjectLock;

        ProjectLock(MavenSession session, MojoDescriptor mojoDescriptor) {
            mojos.put(Thread.currentThread(), mojoDescriptor);
            if (session.getRequest().getDegreeOfConcurrency() > 1) {
                boolean aggregator = mojoDescriptor.isAggregator();

    }

    public BuildSummary getBuildSummary(MavenProject project) {
        return buildSummaries.get(project);
    }

    public void addBuildSummary(BuildSummary summary) {
        buildSummaries.put(summary.getProject(), summary);
    }

    @Override
    public boolean canResume() {
        return canResume;
    }

    @Override
    public void setCanResume(boolean canResume) {

            this.extensionArtifactFilter = extensionArtifactFilter;
        }
    }

    Key createKey(List<? extends ClassRealm> extensionRealms);

    CacheRecord get(Key key);

    CacheRecord put(Key key, ClassRealm projectRealm, DependencyFilter extensionArtifactFilter);

    void flush();

    /**
     * Registers the specified cache record for usage with the given project. Integrators can use the information

                    if (ret != null) {
                        return ret;
                    }
                    cycle.removeLast();
                    stateMap.put(v, DfsState.VISITED);
                } else if (state == DfsState.VISITING) {
                    // we are already visiting this vertex, this mean we have a cycle
                    int pos = cycle.lastIndexOf(v);

                    if (existing != null) {
                        existing = mergePlugin(existing, element, sourceDominant, context);
                        master.put(key, existing);
                        if (!pending.isEmpty()) {
                            predecessors.put(key, pending);
                            pending = new ArrayList<>();
                        }
                    } else {

        Map<String, String> properties = new HashMap<>();
        properties.put(ArtifactProperties.TYPE, id);
        properties.put(ArtifactProperties.LANGUAGE, language.id());
        properties.put(MavenArtifactProperties.INCLUDES_DEPENDENCIES, Boolean.toString(includesDependencies));
        properties.put(
                MavenArtifactProperties.CONSTITUTES_BUILD_PATH,