jdk/src/java.base/share/classes/java/lang/module/Configuration.java
changeset 37779 7c84df693837
parent 36511 9d0388c6b336
child 38457 3d019217e322
equal deleted inserted replaced
37662:ec60c3290242 37779:7c84df693837
    23  * questions.
    23  * questions.
    24  */
    24  */
    25 
    25 
    26 package java.lang.module;
    26 package java.lang.module;
    27 
    27 
       
    28 import java.io.PrintStream;
    28 import java.util.Collection;
    29 import java.util.Collection;
    29 import java.util.Collections;
    30 import java.util.Collections;
    30 import java.util.HashMap;
    31 import java.util.HashMap;
    31 import java.util.Map;
    32 import java.util.Map;
    32 import java.util.Objects;
    33 import java.util.Objects;
   181         this.graph = Collections.emptyMap();
   182         this.graph = Collections.emptyMap();
   182         this.modules = Collections.emptySet();
   183         this.modules = Collections.emptySet();
   183         this.nameToModule = Collections.emptyMap();
   184         this.nameToModule = Collections.emptyMap();
   184     }
   185     }
   185 
   186 
   186     private Configuration(Configuration parent, Resolver resolver) {
   187     private Configuration(Configuration parent,
   187         Map<ResolvedModule, Set<ResolvedModule>> graph = resolver.finish(this);
   188                           Resolver resolver,
       
   189                           boolean check)
       
   190     {
       
   191         Map<ResolvedModule, Set<ResolvedModule>> g = resolver.finish(this, check);
   188 
   192 
   189         Map<String, ResolvedModule> nameToModule = new HashMap<>();
   193         Map<String, ResolvedModule> nameToModule = new HashMap<>();
   190         for (ResolvedModule resolvedModule : graph.keySet()) {
   194         for (ResolvedModule resolvedModule : g.keySet()) {
   191             nameToModule.put(resolvedModule.name(), resolvedModule);
   195             nameToModule.put(resolvedModule.name(), resolvedModule);
   192         }
   196         }
   193 
   197 
   194         this.parent = parent;
   198         this.parent = parent;
   195         this.graph = graph;
   199         this.graph = g;
   196         this.modules = Collections.unmodifiableSet(graph.keySet());
   200         this.modules = Collections.unmodifiableSet(g.keySet());
   197         this.nameToModule = Collections.unmodifiableMap(nameToModule);
   201         this.nameToModule = Collections.unmodifiableMap(nameToModule);
   198     }
   202     }
   199 
   203 
   200 
   204 
   201     /**
   205     /**
   281     {
   285     {
   282         Objects.requireNonNull(before);
   286         Objects.requireNonNull(before);
   283         Objects.requireNonNull(after);
   287         Objects.requireNonNull(after);
   284         Objects.requireNonNull(roots);
   288         Objects.requireNonNull(roots);
   285 
   289 
   286         Resolver resolver = new Resolver(before, this, after);
   290         Resolver resolver = new Resolver(before, this, after, null);
   287         resolver.resolveRequires(roots);
   291         resolver.resolveRequires(roots);
   288 
   292 
   289         return new Configuration(this, resolver);
   293         return new Configuration(this, resolver, true);
   290     }
   294     }
   291 
   295 
   292 
   296 
   293     /**
   297     /**
   294      * Resolves a collection of root modules, with service binding, and with
   298      * Resolves a collection of root modules, with service binding, and with
   338     {
   342     {
   339         Objects.requireNonNull(before);
   343         Objects.requireNonNull(before);
   340         Objects.requireNonNull(after);
   344         Objects.requireNonNull(after);
   341         Objects.requireNonNull(roots);
   345         Objects.requireNonNull(roots);
   342 
   346 
   343         Resolver resolver = new Resolver(before, this, after);
   347         Resolver resolver = new Resolver(before, this, after, null);
   344         resolver.resolveRequires(roots).resolveUses();
   348         resolver.resolveRequires(roots).resolveUses();
   345 
   349 
   346         return new Configuration(this, resolver);
   350         return new Configuration(this, resolver, true);
       
   351     }
       
   352 
       
   353 
       
   354     /**
       
   355      * Resolves a collection of root modules, with service binding, and with
       
   356      * the empty configuration as its parent. The post resolution checks
       
   357      * are optionally run.
       
   358      *
       
   359      * This method is used to create the configuration for the boot layer.
       
   360      */
       
   361     static Configuration resolveRequiresAndUses(ModuleFinder finder,
       
   362                                                 Collection<String> roots,
       
   363                                                 boolean check,
       
   364                                                 PrintStream traceOutput)
       
   365     {
       
   366         Configuration parent = empty();
       
   367 
       
   368         Resolver resolver
       
   369             = new Resolver(finder, parent, ModuleFinder.empty(), traceOutput);
       
   370         resolver.resolveRequires(roots).resolveUses();
       
   371 
       
   372         return new Configuration(parent, resolver, check);
   347     }
   373     }
   348 
   374 
   349 
   375 
   350     /**
   376     /**
   351      * Returns the <em>empty</em> configuration. The empty configuration does
   377      * Returns the <em>empty</em> configuration. The empty configuration does