/*
         * Initialize mapping from lifecycle phase to bound mojos. The key set of this map denotes the phases the caller
         * is interested in, i.e. all phases up to and including the specified phase.
         */

        Map<String, Map<Integer, List<MojoExecution>>> mappings = new LinkedHashMap<>();

        for (String phase : lifecycle.getPhases()) {

     * not specified, Maven will use the lifecycle of the current build.
     *
     * @see <a href="https://maven.apache.org/maven-plugin-api/lifecycle-mappings.html">Lifecycle Mappings</a>
     * @return the lifecycle id
     */
    @Nonnull
    String lifecycle() default "";

import org.apache.maven.artifact.repository.ArtifactRepository;

/**
 * Metadata for the artifact version directory of the repository.
 *
 * TODO split instantiation (versioning, plugin mappings) from definition
 */
@Deprecated
public class SnapshotArtifactRepositoryMetadata extends AbstractRepositoryMetadata {
    private Artifact artifact;

    public SnapshotArtifactRepositoryMetadata(Artifact artifact) {

import org.apache.maven.lifecycle.LifeCyclePluginAnalyzer;
import org.apache.maven.lifecycle.Lifecycle;
import org.apache.maven.lifecycle.mapping.LifecycleMapping;
import org.apache.maven.lifecycle.mapping.LifecycleMojo;
import org.apache.maven.lifecycle.mapping.LifecyclePhase;
import org.apache.maven.model.InputLocation;
import org.apache.maven.model.InputSource;
import org.apache.maven.model.Plugin;

    private boolean parallel;

    /**
     * Plugin context keyed by project ({@link MavenProject#getId()}) and by plugin lookup key
     * ({@link PluginDescriptor#getPluginLookupKey()}). Plugin contexts itself are mappings of {@link String} keys to
     * {@link Object} values.
     */
    @SuppressWarnings("checkstyle:linelength")
    private final ConcurrentMap<String, ConcurrentMap<String, ConcurrentMap<String, Object>>>

          <description>The phase mappings for this lifecycle.</description>
          <association>
            <type>Phase</type>
            <multiplicity>*</multiplicity>
          </association>
        </field>
      </fields>
    </class>
    <class>
      <name>Phase</name>
      <version>1.0.0</version>
      <description>A phase mapping definition.</description>
      <fields>
        <field>

                Collections.unmodifiableMap(lifecycles.stream().collect(toMap(Lifecycle::getId, identity())));
    }

    /**
     * Plexus: Populates the lifecycle map from the injected list of lifecycle mappings (if not already done).
     */
    private synchronized void initLifecycleMap() {
        if (lifecycleMap == null) {
            lifecycleMap = new HashMap<>();

            if (lifecycles != null) {

     * @param newValue the data to associate with the key, may be {@code null} to remove the mapping
     * @return {@code true} if the key mapping was successfully updated from the old value to the new value,
     *         {@code false} if the current key mapping didn't match the expected value and was not updated.
     */
    <T> boolean replace(@Nonnull Key<T> key, @Nullable T oldValue, @Nullable T newValue);

    }

    // groupId -> (artifactId -> (version -> project)))
    private Map<String, Map<String, Map<String, MavenProject>>> getAllProjects() {
        // compute the projects mapping
        if (allProjects == null) {
            List<MavenProject> allProjects = session.getAllProjects();
            if (allProjects != null) {

apOrientedComponent.class package org.codehaus.plexus.component.composition; public synchronized class MapOrientedComponent extends AbstractComponentCom { private static String SINGLE_MAPPING_TYPE; private static String MAP_MAPPING_TYPE; private static String SET_MAPPING_TYPE; private static String DEFAULT_MAPPING_TYPE; public void MapOrientedComponent(); public void verifyComponentSuita(Object) throws CompositionException; public void assignRequirement(Object, org.codehaus.plexus.component.repo...