<code>
            <![CDATA[
    /**
     * Computes a hash value based on {@link #getType()} and {@link #getProvides()} values.
     */
    public int hashCode() {
        return java.util.Objects.hash(getType(), getProvides());
    } //-- int hashCode()

    /**
     * Checks equality based on {@link #getType()} and {@link #getProvides()} values.
     */
    public boolean equals(Object other) {

                        plugins.put(key, pluginMetadata);
                    }
                }
            }
        }
        return plugins.values();
    }

    private PluginInfo extractPluginInfo(Artifact artifact) {
        // sanity: jar, no classifier and file exists
        if (artifact != null
                && "jar".equals(artifact.getExtension())

            List<MojoExecution> mojoExecutions = new ArrayList<>();

            for (List<MojoExecution> executions : entry.getValue().values()) {
                mojoExecutions.addAll(executions);
            }

            lifecycleMappings.put(entry.getKey(), mojoExecutions);
        }

        return lifecycleMappings;
    }

            pathTypes.put(path, type);
        }
        return type;
    }

    /**
     * Selects the type of path where to place the given dependency.
     * This method returns one of the values specified in the given collection.
     * This method does not handle the patch-module paths, because the patches
     * depend on which modules have been previously added on the module-paths.
     *

    }

    /**
     * Creates a new Maven-like repository system session by initializing the session with values typical for
     * Maven-based resolution. In more detail, this method configures settings relevant for the processing of dependency
     * graphs, most other settings remain at their generic default value. Use the various setters to further configure

        CacheRecord record = new CacheRecord(pluginRealm, pluginArtifacts);

        cache.put(key, record);

        return record;
    }

    public void flush() {
        for (CacheRecord record : cache.values()) {
            ClassRealm realm = record.getRealm();
            try {
                realm.getWorld().disposeRealm(realm.getId());
            } catch (NoSuchRealmException e) {
                // ignore

     * Gets the location of the problem. The location is a user-friendly combination of the values from
     * {@link #getSource()}, {@link #getLineNumber()} and {@link #getColumnNumber()}. The exact syntax of the returned
     * value is undefined.
     *
     * @return The location of the problem, never {@code null}.
     */
    String getLocation();

    /**
     * Gets the exception that caused this problem (if any).
     *

    /**
     * System scope.
     */
    SYSTEM("system", false);

    private static final Map<String, DependencyScope> IDS = Collections.unmodifiableMap(
            Stream.of(DependencyScope.values()).collect(Collectors.toMap(s -> s.id, s -> s)));

    public static DependencyScope forId(String id) {
        return IDS.get(id);
    }

    private final String id;
    private final boolean transitive;

        <field>
          <name>configurator</name>
          <version>1.0.0+</version>
          <type>String</type>
          <description>
            The configurator type to use when injecting parameter values into this Mojo. The value is normally deduced
            from the Mojo's implementation language, but can be specified to allow a custom ComponentConfigurator
            implementation to be used.
          </description>

                    value = ReflectionValueExtractor.evaluate(pathExpression, session);
                    if (pathSeparator < expression.length() - 1) {
                        if (value instanceof Path) {
                            value = ((Path) value).resolve(expression.substring(pathSeparator + 1));
                        } else {
                            value = value + expression.substring(pathSeparator);