Java ModuleDescriptor.isAutomatic方法代码示例

import java.lang.module.ModuleDescriptor; //导入方法依赖的package包/类
private static Builder toBuilder(ModuleDescriptor descriptor) {
  String name = descriptor.name();
  Set<Modifier> modifiers = descriptor.isAutomatic()? Set.of(Modifier.AUTOMATIC):
    descriptor.isOpen()? Set.of(Modifier.OPEN): Set.of();
  Builder builder = ModuleDescriptor.newModule(name, modifiers);
  
  descriptor.requires().forEach(builder::requires);
  descriptor.exports().forEach(builder::exports);
  descriptor.opens().forEach(builder::opens);
  
  HashSet<String> packages = new HashSet<>(descriptor.packages());
  descriptor.exports().forEach(export -> packages.remove(export.source()));
  descriptor.opens().forEach(open -> packages.remove(open.source()));
  builder.packages(packages);
  
  descriptor.uses().forEach(builder::uses);
  descriptor.provides().forEach(builder::provides);
  
  return builder;
}
 

import java.lang.module.ModuleDescriptor; //导入方法依赖的package包/类
/**
 * Creates a new named Module. The resulting Module will be defined to the
 * VM but will not read any other modules, will not have any exports setup
 * and will not be registered in the service catalog.
 */
Module(ModuleLayer layer,
       ClassLoader loader,
       ModuleDescriptor descriptor,
       URI uri)
{
    this.layer = layer;
    this.name = descriptor.name();
    this.loader = loader;
    this.descriptor = descriptor;

    // define module to VM

    boolean isOpen = descriptor.isOpen() || descriptor.isAutomatic();
    Version version = descriptor.version().orElse(null);
    String vs = Objects.toString(version, null);
    String loc = Objects.toString(uri, null);
    String[] packages = descriptor.packages().toArray(new String[0]);
    defineModule0(this, isOpen, vs, loc, packages);
}
 

import java.lang.module.ModuleDescriptor; //导入方法依赖的package包/类
/**
 * Returns true if the given module opens the given package
 * unconditionally.
 *
 * @implNote This method currently iterates over each of the open
 * packages. This will be replaced once the ModuleDescriptor.Opens
 * API is updated.
 */
private boolean isOpen(ModuleReference mref, String pn) {
    ModuleDescriptor descriptor = mref.descriptor();
    if (descriptor.isOpen() || descriptor.isAutomatic())
        return true;
    for (ModuleDescriptor.Opens opens : descriptor.opens()) {
        String source = opens.source();
        if (!opens.isQualified() && source.equals(pn)) {
            return true;
        }
    }
    return false;
}
 

import java.lang.module.ModuleDescriptor; //导入方法依赖的package包/类
/**
 * Prints a single line with the module name, version and modifiers
 */
private static void showModule(ModuleReference mref) {
    ModuleDescriptor md = mref.descriptor();
    ostream.print(md.toNameAndVersion());
    mref.location()
            .filter(uri -> !isJrt(uri))
            .ifPresent(uri -> ostream.format(" %s", uri));
    if (md.isOpen())
        ostream.print(" open");
    if (md.isAutomatic())
        ostream.print(" automatic");
    ostream.println();
}
 

import java.lang.module.ModuleDescriptor; //导入方法依赖的package包/类
/**
 * Prints the module location and name.
 */
private void printModule(ModuleReference mref) {
    mref.location()
        .filter(uri -> !isJrt(uri))
        .ifPresent(uri -> ostream.print(uri + " "));
    ModuleDescriptor descriptor = mref.descriptor();
    ostream.print(descriptor.name());
    if (descriptor.isAutomatic())
        ostream.print(" automatic");
    ostream.println();
}
 

import java.lang.module.ModuleDescriptor; //导入方法依赖的package包/类
ModuleDescriptorBuilder(ModuleDescriptor md, Set<String> packages, int index) {
    if (md.isAutomatic()) {
        throw new InternalError("linking automatic module is not supported");
    }
    this.md = md;
    this.packages = packages;
    this.index = index;
}