}

    /**
     * Adds the given path element to the specified type of path.
     *
     * @param type the type of path (class-path, module-path, …)
     * @param path the path element to add
     */
    private void addPathElement(PathType type, Path path) {
        dispatchedPaths.computeIfAbsent(type, (t) -> new ArrayList<>()).add(path);
    }

    /**

     * Note that this option is incomplete, because it must be followed by a module name.
     * Use this type only when the module to patch is unknown.
     *
     * @see #patchModule(String)
     */
    PATCH_MODULE("--patch-module"),

    /**
     * The path identified by the Java {@code --processor-path} option.
     */
    PROCESSOR_CLASSES("--processor-path"),

    /**

     * @return the option associated to this path type followed by the given path elements,
     *         or an empty string if there is no path element.
     */
    @Nonnull
    String option(Iterable<? extends Path> paths);

    /**
     * Returns the name of this path type. For example, if this path type
     * is {@link JavaPathType#MODULES}, then this method returns {@code "MODULES"}.
     *

                        Language.JAVA_FAMILY,
                        "jar",
                        "tests",
                        false,
                        JavaPathType.CLASSES,
                        JavaPathType.PATCH_MODULE),
                new DefaultType(Type.MODULAR_JAR, Language.JAVA_FAMILY, "jar", null, false, JavaPathType.MODULES),

     */
    @Nonnull
    Map<PathType, List<Path>> getDispatchedPaths();

    @Nonnull
    Map<Dependency, Path> getDependencies();

    /**
     * Formats the command-line option for the path of the specified type.
     * The option are documented in {@link org.apache.maven.api.JavaPathType} enumeration values.
     *
     * @param type the desired type of path (class-path, module-path, …)
     * @return the option to pass to Java tools

    }

    /**
     * Adds the given path element to the specified type of path.
     *
     * @param type the type of path (class-path, module-path, …)
     * @param path the path element to add
     */
    private void addPathElement(PathType type, Path path) {
        dispatchedPaths.computeIfAbsent(type, (t) -> new ArrayList<>()).add(path);
    }

    /**

        checkVersionParsing("1.7.3.0", 0, 0, 0, 0, "1.7.3.0");
        checkVersionParsing("1.7.3.0-1", 0, 0, 0, 0, "1.7.3.0-1");
        checkVersionParsing("PATCH-1193602", 0, 0, 0, 0, "PATCH-1193602");
        checkVersionParsing("5.0.0alpha-2006020117", 0, 0, 0, 0, "5.0.0alpha-2006020117");
        checkVersionParsing("1.0.0.-SNAPSHOT", 0, 0, 0, 0, "1.0.0.-SNAPSHOT");

     * or on the module-path when the {@code "jar"} artifact type is used.
     */
    private PathType getPathType(Path path) throws IOException {
        PathType type = pathTypes.get(path);
        if (type == null) {
            type = new PathModularization(path, false).getPathType();
            pathTypes.put(path, type);
        }
        return type;
    }

    /**
     * Types of path (class-path, module-path, …) where the dependency can be placed.
     * For most deterministic builds, the array length should be 1. In such case,
     * the dependency will be unconditionally placed on the specified type of path
     * and no heuristic rule will be involved.
     *
     * <p>It is nevertheless common to specify two or more types of path. For example,

     * or on the module-path when the {@code "jar"} artifact type is used.
     */
    private PathType getPathType(Path path) throws IOException {
        PathType type = pathTypes.get(path);
        if (type == null) {
            type = new PathModularization(path, false).getPathType();
            pathTypes.put(path, type);
        }
        return type;
    }