/**
     * Add a compilation source root to the given project for the given scope.
     * The path will be transformed into an absolute path and added to the list for the given scope,
     * if not already present.
     *
     * @param project the project
     * @param scope the scope, i.e. usually main or test
     * @param sourceRoot the new source root

some work here to figure out how a dispatching to a particular plugin would occur because everything needs to be mediated through the host application. For a given action that is possible for a user to perform in the UI we need to know the URI that is to be used with its given parameters. That URI in turn must map internally to a method in a given component which belongs to a plugin. This mapping should actually be more generalized and it shouldn’t matter internally whether this maps to the core application...

    /**
     * Performs a lookup for given typed component.
     *
     * @param type The component type.
     * @return The component.
     * @param <T> The component type.
     * @throws LookupException if no such component or there is some provisioning related issue.
     */
    @Nonnull
    <T> T lookup(Class<T> type);

    /**
     * Performs a lookup for given typed component.
     *

         * The path elements are separated by an option-specific or platform-specific separator.
         * If the given {@code paths} argument contains no element, then this method returns an empty string.
         *
         * @param paths the path to format as a string
         * @return the option associated to this path type followed by the given path elements,

     * Adds a dependency to the result. This method populates the {@link #nodes}, {@link #paths},
     * {@link #dispatchedPaths} and {@link #dependencies} collections with the given arguments.
     *
     * @param node the dependency node
     * @param dep the dependency for the given node, or {@code null} if none
     * @param filter filter the paths accepted by the tool which will consume the path.

     *
     * @see #NONE
     */
    private PathModularization() {
        descriptors = Collections.emptyMap();
        isModuleHierarchy = false;
    }

    /**
     * Finds module information in the given JAR file, output directory, or test output directory.
     * If no module is found, or if module information cannot be extracted, then this constructor
     * builds an empty map.
     *

/**
 * ModelProcessor
 */
public interface ModelProcessor {

    /**
     * Returns the file containing the pom to be parsed or null if a pom can not be found
     * at the given file or in the given directory.
     */
    @Nullable
    Path locateExistingPom(@Nonnull Path project);

    /**
     * Reads the model from the specified byte stream. The stream will be automatically closed before the method

     */
    List<MavenProject> getSortedProjects();

    /**
     * Gets the downstream projects of the specified project. A downstream project is a project that directly or
     * indirectly depends on the given project.
     *
     * @param project The project whose downstream projects should be retrieved, must not be {@code null}.

    public static <T> Result<T> newResult(T model, Iterable<? extends ModelProblem> problems) {
        return new Result<>(hasErrors(problems), model, problems);
    }

    /**
     * New result consisting of given result and new problem. Convenience for newResult(result.get(),
     * concat(result.getProblems(),problems)).
     *
     * @param result
     * @param problem
     */

    /**
     * @param session the repository session
     * @param artifact the {@link Artifact} to install
     * @throws ArtifactInstallerException In case of an error which can be the a given artifact cannot be found or the
     *             installation has failed.
     * @throws IllegalArgumentException in case of parameter {@code session} is {@code null} or
     *          {@code artifact} is {@code null}.
     */