Class DefaultDependencyResolverResult

java.lang.Object
org.apache.maven.internal.impl.DefaultDependencyResolverResult
All Implemented Interfaces:
DependencyResolverResult

class DefaultDependencyResolverResult extends Object implements DependencyResolverResult
The result of collecting dependencies with a dependency resolver. New instances are initially empty. Callers must populate with calls to the following methods, in that order:
See Also:
  • Field Details

    • exceptions

      private final List<Exception> exceptions
      The exceptions that occurred while building the dependency graph.
    • root

      private final Node root
      The root node of the dependency graph.
    • nodes

      private final List<Node> nodes
      The ordered list of the flattened dependency nodes.
    • paths

      private final List<Path> paths
      The file paths of all dependencies, regardless on which Java tool option those paths should be placed.
    • dispatchedPaths

      private final Map<PathType,List<Path>> dispatchedPaths
      The file paths of all dependencies, dispatched according the Java options where to place them.
    • dependencies

      private final Map<Dependency,Path> dependencies
      The dependencies together with the path to each dependency.
    • outputModules

      private PathModularization outputModules
      Information about modules in the main output. This field is initially null and is set to a non-null value when the output directories have been set, or when it is too late for setting them.
    • cache

      private final PathModularizationCache cache
      Cache of module information about each dependency.
  • Constructor Details

    • DefaultDependencyResolverResult

      DefaultDependencyResolverResult(PathModularizationCache cache, List<Exception> exceptions, Node root, int count)
      Creates an initially empty result. Callers should add path elements by calls to addDependency(Node, Dependency, Predicate, Path).
      Parameters:
      cache - cache of module information about each dependency
      exceptions - the exceptions that occurred while building the dependency graph
      root - the root node of the dependency graph
      count - estimated number of dependencies
  • Method Details

    • addPathElement

      private void addPathElement(PathType type, Path path)
      Adds the given path element to the specified type of path.
      Parameters:
      type - the type of path (class-path, module-path, …)
      path - the path element to add
    • addOutputDirectory

      void addOutputDirectory(Path main, Path test) throws IOException
      Adds main and test output directories to the result. This method adds the main output directory to the module-path if it contains a module-info.class, or to the class-path otherwise. For the test output directory, the rules are more complex and are governed by the fact that Java does not accept the placement of two modules of the same name on the module-path. So the modular test output directory usually needs to be placed in a --path-module option.
      • If the test output directory is modular, then:
        • If a test module name is identical to a main module name, place the test directory in a --patch-module option.
        • Otherwise, place the test directory on the module-path. However, this case (a module existing only in test output, not in main output) should be uncommon.
      • Otherwise (test output contains no module information), then:
        • If the main output is on the module-path, place the test output on a --patch-module option.
        • Otherwise (main output on the class-path), place the test output on the class-path too.
      This method must be invoked before addDependency(Node, Dependency, Predicate, Path) if output directories are desired on the class-path or module-path. This method can be invoked at most once.
      Parameters:
      main - the main output directory, or null if none
      test - the test output directory, or null if none
      Throws:
      IOException - if an error occurred while reading module information TODO: this is currently not called. This is intended for use by Surefire and may move there.
    • addNode

      void addNode(Node node)
      Adds a dependency node to the result.
      Parameters:
      node - the dependency node
    • addDependency

      void addDependency(Node node, Dependency dep, Predicate<PathType> filter, Path path) throws IOException
      Adds a dependency to the result. This method populates the nodes, paths, dispatchedPaths and dependencies collections with the given arguments.
      Parameters:
      node - the dependency node
      dep - the dependency for the given node, or null if none
      filter - filter the paths accepted by the tool which will consume the path.
      path - the path to the dependency, or null if the dependency was null
      Throws:
      IOException - if an error occurred while reading module information
    • containsPatches

      private boolean containsPatches(Set<PathType> types)
      Returns whether the given set of path types contains at least one patch for a module.
    • containsModule

      private boolean containsModule(String moduleName) throws IOException
      Returns whether at least one previously added modular dependency contains a module of the given name.
      Parameters:
      moduleName - name of the module to search
      Throws:
      IOException
    • findArtifactPath

      private Path findArtifactPath(String group, String artifact) throws IOException
      Searches an artifact of the given group and artifact identifiers, and returns its path
      Parameters:
      group - the group identifier to search
      artifact - the artifact identifier to search
      Returns:
      path to the desired artifact, or null if not found
      Throws:
      IOException
    • getExceptions

      public List<Exception> getExceptions()
      Description copied from interface: DependencyResolverResult
      Gets the exceptions that occurred while building the dependency graph.
      Specified by:
      getExceptions in interface DependencyResolverResult
      Returns:
      the exceptions that occurred, never null
    • getRoot

      public Node getRoot()
      Description copied from interface: DependencyResolverResult
      Gets the root node of the dependency graph.
      Specified by:
      getRoot in interface DependencyResolverResult
      Returns:
      the root node of the dependency graph or null if none
    • getNodes

      public List<Node> getNodes()
      Description copied from interface: DependencyResolverResult
      The ordered list of the flattened dependency nodes.
      Specified by:
      getNodes in interface DependencyResolverResult
      Returns:
      the ordered list of the flattened dependency nodes
    • getPaths

      public List<Path> getPaths()
      Description copied from interface: DependencyResolverResult
      Returns the file paths of all dependencies, regardless on which tool option those paths should be placed. The returned list may contain a mix of Java class-path, Java module-path, and other types of path elements. This collection has the same content than getDependencies.values() except that it does not contain null elements.
      Specified by:
      getPaths in interface DependencyResolverResult
      Returns:
      the paths of all dependencies
    • getDispatchedPaths

      public Map<PathType,List<Path>> getDispatchedPaths()
      Description copied from interface: DependencyResolverResult
      Returns the file paths of all dependencies, dispatched according the tool options where to place them. The PathType keys identify, for example, --class-path or --module-path options. In the case of Java tools, the map may also contain --patch-module options, which are handled in a special way.

      Design note

      All types of path are determined together because they are sometime mutually exclusive. For example, an artifact of type "jar" can be placed either on the class-path or on the module-path. The project needs to make a choice (possibly using heuristic rules), then to add the dependency in only one of the options identified by PathType.
      Specified by:
      getDispatchedPaths in interface DependencyResolverResult
      Returns:
      file paths to place on the different tool options
    • getDependencies

      public Map<Dependency,Path> getDependencies()
      Description copied from interface: DependencyResolverResult
      Returns all dependencies associated to their paths. Some dependencies may be associated to a null value if there is no path available.
      Specified by:
      getDependencies in interface DependencyResolverResult
      Returns:
      all dependencies associated to their paths
    • getModuleDescriptor

      public Optional<ModuleDescriptor> getModuleDescriptor(Path dependency) throws IOException
      Description copied from interface: DependencyResolverResult
      Returns the Java module descriptor of the dependency at the given path. The given dependency should be one of the paths returned by DependencyResolverResult.getDependencies(). The module descriptor is extracted from the module-info.class file if present.

      DependencyResolverResult.getModuleName(Path) is preferred when only the module name is desired, because a name may be present even if the descriptor is absent. This method is for cases when more information is desired, such as the set of exported packages.

      Specified by:
      getModuleDescriptor in interface DependencyResolverResult
      Parameters:
      dependency - path to the dependency for which to get the module name
      Returns:
      module name of the dependency at the given path, or empty if the dependency is not modular
      Throws:
      IOException - if the module information of the specified dependency cannot be read
    • getModuleName

      public Optional<String> getModuleName(Path dependency) throws IOException
      Description copied from interface: DependencyResolverResult
      Returns the Java module name of the dependency at the given path. The given dependency should be one of the paths returned by DependencyResolverResult.getDependencies(). The module name is extracted from the module-info.class file if present, otherwise from the "Automatic-Module-Name" attribute of the META-INF/MANIFEST.MF file if present.

      A typical usage is to invoke this method for all dependencies having a TEST or TEST_ONLY scope. An --add-reads option may need to be generated for compiling and running the test classes that use such dependencies.

      Specified by:
      getModuleName in interface DependencyResolverResult
      Parameters:
      dependency - path to the dependency for which to get the module name
      Returns:
      module name of the dependency at the given path, or empty if the dependency is not modular
      Throws:
      IOException - if the module information of the specified dependency cannot be read
    • name

      private static String name(Object value)
      Returns the module name for the given value of the PathModularization.descriptors map.
    • warningForFilenameBasedAutomodules

      public Optional<String> warningForFilenameBasedAutomodules()
      Description copied from interface: DependencyResolverResult
      If the module-path contains at least one filename-based auto-module, prepares a warning message. The module path is the collection of dependencies associated to JavaPathType.MODULES. It is caller's responsibility to send the message to a logger.
      Specified by:
      warningForFilenameBasedAutomodules in interface DependencyResolverResult
      Returns:
      warning message if at least one filename-based auto-module was found