*
 * This is because the ModelProcessor interface extends ModelLocator and ModelReader. If we
 * made this component available under all its interfaces then it could end up being injected
 * into itself leading to a stack overflow.
 *
 * A side effect of using @Typed is that it translates to explicit bindings in the container.
 * So instead of binding the component under a 'wildcard' key it is now bound with an explicit

    private Artifact artifact;

    // Needs to go away
    // These are really overrides now, projects defining dependencies for a plugin that override what is
    // specified in the plugin itself.
    private Set<Artifact> artifactDependencies;

    private ArtifactRepository localRepository;

    private List<ArtifactRepository> remoteRepositories;

    private ArtifactFilter collectionFilter;

       <value>classic</value>
     </parameter>
   </parameters>
  </plugin>
</plugins>
+-----+

Unified source directory

 Unified source directory structure that is analogous to the repository
 itself. This way locations of intermediary artifacts of a build would be
 in a known location. This would also help with developer setup i.e. getting
 new developers up and running. They could run a maven command and have all

        //
        // If we have a system scoped artifact then we do not want any searching in local or remote repositories
        // and we want artifact resolution to only return the system scoped artifact itself.
        //
        if (artifact.getScope() != null && artifact.getScope().equals(Artifact.SCOPE_SYSTEM)) {
            return new ResolutionGroup(null, null, null);
        }

                // a self reference or in other words a circular reference which can not being resolved.
                addViolation(
                        problems,
                        Severity.FATAL,
                        Version.V31,
                        prefix + "[" + key + "]",
                        key,
                        "is referencing itself.",
                        dependency);

                                        }
                                    }
                                } finally {
                                    // in ITs test we need only reports from test itself
                                    // test projects can contain reports with tested failed builds

attributes on the instantiated LogFactory instance. Once an implementation class name is selected, the corresponding class is loaded from the current Thread context class loader (if there is one), or from the class loader that loaded the LogFactory class itself otherwise. This allows a copy of commons-logging.jar to be shared in a multiple class loader environment (such as a servlet container), but still allow each web application to provide its own LogFactory implementation, if it so desires. An instance...

                sums.put(extension, observer.getActualChecksum());
            }

            // We do this in here so we can checksum the artifact metadata too, otherwise it could be metadata itself
            for (String extension : checksums.keySet()) {
                // TODO shouldn't need a file intermediary - improve wagon to take a stream
                File temp = File.createTempFile("maven-artifact", null);

 */
@Experimental
@Immutable
@SuppressWarnings("checkstyle:InterfaceIsType")
public interface Language extends ExtensibleEnum {

    /**
     * The "none" language. It is not versioned, family is same to itself, and compatible with itself only.
     * In turn, every {@link Language} implementation must be compatible with {@code NONE} language.
     */
    Language NONE = language("none");

 */
@Experimental
public class XmlWriterException extends MavenException {

    private final Location location;

    /**
     * @param message the message for the exception
     * @param e the exception itself
     */
    public XmlWriterException(String message, Location location, Exception e) {
        super(message, e);
        this.location = location;
    }

    public Location getLocation() {