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

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

        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();

        this.problems.addAll(result.getProblems());

        for (String modelId : result.getModelIds()) {
            this.modelIds.add(modelId);
            this.rawModels.put(modelId, result.getRawModel(modelId).orElseThrow());
            this.activePomProfiles.put(modelId, result.getActivePomProfiles(modelId));
        }
    }

    @Override
    public Model getFileModel() {
        return fileModel;
    }

                Model model = findRawModel(from, gId, aId);
                if (model != null) {
                    context.modelByGA.put(new GAKey(gId, aId), new Holder(model));
                    context.modelByPath.put(model.getPomFile(), new Holder(model));
                }
                return model;
            }

            @Override

        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,

     */
    public void activateRequiredProfile(String id) {
        this.activations.put(id, ActivationSettings.ACTIVATION_REQUIRED);
    }

    /**
     * Mark a profile as optional and activated.
     * @param id The identifier of the profile.
     */
    public void activateOptionalProfile(String id) {
        this.activations.put(id, ActivationSettings.ACTIVATION_OPTIONAL);
    }

    /**