src/jdk.jdeps/share/classes/com/sun/tools/jdeps/Module.java - platform/libcore - Git at Google

 /*
  * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.  Oracle designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */

 package com.sun.tools.jdeps;

 import java.lang.module.ModuleDescriptor;
 import java.net.URI;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Map;
 import java.util.Set;

 /**
  * Jdeps internal representation of module for dependency analysis.
  */
 class Module extends Archive {
     static final Module UNNAMED_MODULE = new UnnamedModule();
     static final String JDK_UNSUPPORTED = "jdk.unsupported";

     static final boolean DEBUG = Boolean.getBoolean("jdeps.debug");
     static void trace(String fmt, Object... args) {
         trace(DEBUG, fmt, args);
     }

     static void trace(boolean traceOn, String fmt, Object... args) {
         if (traceOn) {
             System.err.format(fmt, args);
         }
     }

     private final ModuleDescriptor descriptor;
     private final Map<String, Set<String>> exports;
     private final Map<String, Set<String>> opens;
     private final boolean isSystem;
     private final URI location;

     protected Module(String name) {
         this(name, null, false);
     }

     protected Module(String name, ModuleDescriptor descriptor, boolean isSystem) {
         super(name);
         this.descriptor = descriptor;
         this.location = null;
         this.exports = Collections.emptyMap();
         this.opens = Collections.emptyMap();
         this.isSystem = isSystem;
     }

     private Module(String name,
                    URI location,
                    ModuleDescriptor descriptor,
                    Map<String, Set<String>> exports,
                    Map<String, Set<String>> opens,
                    boolean isSystem,
                    ClassFileReader reader) {
         super(name, location, reader);
         this.descriptor = descriptor;
         this.location = location;
         this.exports = Collections.unmodifiableMap(exports);
         this.opens = Collections.unmodifiableMap(opens);
         this.isSystem = isSystem;
     }

     /**
      * Returns module name
      */
     public String name() {
         return descriptor != null ? descriptor.name() : getName();
     }

     public boolean isNamed() {
         return descriptor != null;
     }

     public boolean isAutomatic() {
         return descriptor != null && descriptor.isAutomatic();
     }

     public Module getModule() {
         return this;
     }

     public ModuleDescriptor descriptor() {
         return descriptor;
     }

     public URI location() {
         return location;
     }

     public boolean isJDK() {
         String mn = name();
         return isSystem &&
             (mn.startsWith("java.") || mn.startsWith("jdk.") || mn.startsWith("javafx."));
     }

     public boolean isSystem() {
         return isSystem;
     }

     public Map<String, Set<String>> exports() {
         return exports;
     }

     public Set<String> packages() {
         return descriptor.packages();
     }

     public boolean isJDKUnsupported() {
         return JDK_UNSUPPORTED.equals(this.name());
     }

     /**
      * Converts this module to a normal module with the given dependences
      *
      * @throws IllegalArgumentException if this module is not an automatic module
      */
     public Module toNormalModule(Map<String, Boolean> requires) {
         if (!isAutomatic()) {
             throw new IllegalArgumentException(name() + " not an automatic module");
         }
         return new NormalModule(this, requires);
     }

     /**
      * Tests if the package of the given name is exported.
      */
     public boolean isExported(String pn) {
         return exports.containsKey(pn) && exports.get(pn).isEmpty();
     }

     /**
      * Tests if the package of the given name is exported to the target
      * in a qualified fashion.
      */
     public boolean isExported(String pn, String target) {
         return isExported(pn)
                 || exports.containsKey(pn) && exports.get(pn).contains(target);
     }

     /**
      * Tests if the package of the given name is open.
      */
     public boolean isOpen(String pn) {
         return opens.containsKey(pn) && opens.get(pn).isEmpty();
     }

     /**
      * Tests if the package of the given name is open to the target
      * in a qualified fashion.
      */
     public boolean isOpen(String pn, String target) {
         return isOpen(pn)
             || opens.containsKey(pn) && opens.get(pn).contains(target);
     }

     @Override
     public String toString() {
         return name();
     }

     public final static class Builder {
         final String name;
         final ModuleDescriptor descriptor;
         final boolean isSystem;
         ClassFileReader reader;
         URI location;

         public Builder(ModuleDescriptor md) {
             this(md, false);
         }

         public Builder(ModuleDescriptor md, boolean isSystem) {
             this.name = md.name();
             this.descriptor = md;
             this.isSystem = isSystem;
         }

         public Builder location(URI location) {
             this.location = location;
             return this;
         }

         public Builder classes(ClassFileReader reader) {
             this.reader = reader;
             return this;
         }

         public Module build() {
             if (descriptor.isAutomatic() && isSystem) {
                 throw new InternalError("JDK module: " + name + " can't be automatic module");
             }

             Map<String, Set<String>> exports = new HashMap<>();
             Map<String, Set<String>> opens = new HashMap<>();

             if (descriptor.isAutomatic()) {
                 // ModuleDescriptor::exports and opens returns an empty set
                 descriptor.packages().forEach(pn -> exports.put(pn, Collections.emptySet()));
                 descriptor.packages().forEach(pn -> opens.put(pn, Collections.emptySet()));
             } else {
                 descriptor.exports().stream()
                           .forEach(exp -> exports.computeIfAbsent(exp.source(), _k -> new HashSet<>())
                                                  .addAll(exp.targets()));
                 descriptor.opens().stream()
                     .forEach(exp -> opens.computeIfAbsent(exp.source(), _k -> new HashSet<>())
                         .addAll(exp.targets()));
             }
             return new Module(name, location, descriptor, exports, opens, isSystem, reader);
         }
     }

     private static class UnnamedModule extends Module {
         private UnnamedModule() {
             super("unnamed", null, false);
         }

         @Override
         public String name() {
             return "unnamed";
         }

         @Override
         public boolean isExported(String pn) {
             return true;
         }
     }

     /**
      * A normal module has a module-info.class
      */
     private static class NormalModule extends Module {
         private final ModuleDescriptor md;

         /**
          * Converts the given automatic module to a normal module.
          *
          * Replace this module's dependences with the given requires and also
          * declare service providers, if specified in META-INF/services configuration file
          */
         private NormalModule(Module m, Map<String, Boolean> requires) {
             super(m.name(), m.location, m.descriptor, m.exports, m.opens, m.isSystem, m.reader());

             ModuleDescriptor.Builder builder = ModuleDescriptor.newModule(m.name());
             requires.keySet().forEach(mn -> {
                 if (requires.get(mn).equals(Boolean.TRUE)) {
                     builder.requires(Set.of(ModuleDescriptor.Requires.Modifier.TRANSITIVE), mn);
                 } else {
                     builder.requires(mn);
                 }
             });
             // exports all packages
             m.descriptor.packages().forEach(builder::exports);
             m.descriptor.uses().forEach(builder::uses);
             m.descriptor.provides().forEach(builder::provides);
             this.md = builder.build();
         }

         @Override
         public ModuleDescriptor descriptor() {
             return md;
         }
     }
 }
	/*
	* Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	package com.sun.tools.jdeps;

	import java.lang.module.ModuleDescriptor;
	import java.net.URI;
	import java.util.Collections;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.Map;
	import java.util.Set;

	/**
	* Jdeps internal representation of module for dependency analysis.
	*/
	class Module extends Archive {
	static final Module UNNAMED_MODULE = new UnnamedModule();
	static final String JDK_UNSUPPORTED = "jdk.unsupported";

	static final boolean DEBUG = Boolean.getBoolean("jdeps.debug");
	static void trace(String fmt, Object... args) {
	trace(DEBUG, fmt, args);
	}

	static void trace(boolean traceOn, String fmt, Object... args) {
	if (traceOn) {
	System.err.format(fmt, args);
	}
	}

	private final ModuleDescriptor descriptor;
	private final Map<String, Set<String>> exports;
	private final Map<String, Set<String>> opens;
	private final boolean isSystem;
	private final URI location;

	protected Module(String name) {
	this(name, null, false);
	}

	protected Module(String name, ModuleDescriptor descriptor, boolean isSystem) {
	super(name);
	this.descriptor = descriptor;
	this.location = null;
	this.exports = Collections.emptyMap();
	this.opens = Collections.emptyMap();
	this.isSystem = isSystem;
	}

	private Module(String name,
	URI location,
	ModuleDescriptor descriptor,
	Map<String, Set<String>> exports,
	Map<String, Set<String>> opens,
	boolean isSystem,
	ClassFileReader reader) {
	super(name, location, reader);
	this.descriptor = descriptor;
	this.location = location;
	this.exports = Collections.unmodifiableMap(exports);
	this.opens = Collections.unmodifiableMap(opens);
	this.isSystem = isSystem;
	}

	/**
	* Returns module name
	*/
	public String name() {
	return descriptor != null ? descriptor.name() : getName();
	}

	public boolean isNamed() {
	return descriptor != null;
	}

	public boolean isAutomatic() {
	return descriptor != null && descriptor.isAutomatic();
	}

	public Module getModule() {
	return this;
	}

	public ModuleDescriptor descriptor() {
	return descriptor;
	}

	public URI location() {
	return location;
	}

	public boolean isJDK() {
	String mn = name();
	return isSystem &&
	(mn.startsWith("java.") \|\| mn.startsWith("jdk.") \|\| mn.startsWith("javafx."));
	}

	public boolean isSystem() {
	return isSystem;
	}

	public Map<String, Set<String>> exports() {
	return exports;
	}

	public Set<String> packages() {
	return descriptor.packages();
	}

	public boolean isJDKUnsupported() {
	return JDK_UNSUPPORTED.equals(this.name());
	}

	/**
	* Converts this module to a normal module with the given dependences
	*
	* @throws IllegalArgumentException if this module is not an automatic module
	*/
	public Module toNormalModule(Map<String, Boolean> requires) {
	if (!isAutomatic()) {
	throw new IllegalArgumentException(name() + " not an automatic module");
	}
	return new NormalModule(this, requires);
	}

	/**
	* Tests if the package of the given name is exported.
	*/
	public boolean isExported(String pn) {
	return exports.containsKey(pn) && exports.get(pn).isEmpty();
	}

	/**
	* Tests if the package of the given name is exported to the target
	* in a qualified fashion.
	*/
	public boolean isExported(String pn, String target) {
	return isExported(pn)
	\|\| exports.containsKey(pn) && exports.get(pn).contains(target);
	}

	/**
	* Tests if the package of the given name is open.
	*/
	public boolean isOpen(String pn) {
	return opens.containsKey(pn) && opens.get(pn).isEmpty();
	}

	/**
	* Tests if the package of the given name is open to the target
	* in a qualified fashion.
	*/
	public boolean isOpen(String pn, String target) {
	return isOpen(pn)
	\|\| opens.containsKey(pn) && opens.get(pn).contains(target);
	}

	@Override
	public String toString() {
	return name();
	}

	public final static class Builder {
	final String name;
	final ModuleDescriptor descriptor;
	final boolean isSystem;
	ClassFileReader reader;
	URI location;

	public Builder(ModuleDescriptor md) {
	this(md, false);
	}

	public Builder(ModuleDescriptor md, boolean isSystem) {
	this.name = md.name();
	this.descriptor = md;
	this.isSystem = isSystem;
	}

	public Builder location(URI location) {
	this.location = location;
	return this;
	}

	public Builder classes(ClassFileReader reader) {
	this.reader = reader;
	return this;
	}

	public Module build() {
	if (descriptor.isAutomatic() && isSystem) {
	throw new InternalError("JDK module: " + name + " can't be automatic module");
	}

	Map<String, Set<String>> exports = new HashMap<>();
	Map<String, Set<String>> opens = new HashMap<>();

	if (descriptor.isAutomatic()) {
	// ModuleDescriptor::exports and opens returns an empty set
	descriptor.packages().forEach(pn -> exports.put(pn, Collections.emptySet()));
	descriptor.packages().forEach(pn -> opens.put(pn, Collections.emptySet()));
	} else {
	descriptor.exports().stream()
	.forEach(exp -> exports.computeIfAbsent(exp.source(), _k -> new HashSet<>())
	.addAll(exp.targets()));
	descriptor.opens().stream()
	.forEach(exp -> opens.computeIfAbsent(exp.source(), _k -> new HashSet<>())
	.addAll(exp.targets()));
	}
	return new Module(name, location, descriptor, exports, opens, isSystem, reader);
	}
	}

	private static class UnnamedModule extends Module {
	private UnnamedModule() {
	super("unnamed", null, false);
	}

	@Override
	public String name() {
	return "unnamed";
	}

	@Override
	public boolean isExported(String pn) {
	return true;
	}
	}

	/**
	* A normal module has a module-info.class
	*/
	private static class NormalModule extends Module {
	private final ModuleDescriptor md;

	/**
	* Converts the given automatic module to a normal module.
	*
	* Replace this module's dependences with the given requires and also
	* declare service providers, if specified in META-INF/services configuration file
	*/
	private NormalModule(Module m, Map<String, Boolean> requires) {
	super(m.name(), m.location, m.descriptor, m.exports, m.opens, m.isSystem, m.reader());

	ModuleDescriptor.Builder builder = ModuleDescriptor.newModule(m.name());
	requires.keySet().forEach(mn -> {
	if (requires.get(mn).equals(Boolean.TRUE)) {
	builder.requires(Set.of(ModuleDescriptor.Requires.Modifier.TRANSITIVE), mn);
	} else {
	builder.requires(mn);
	}
	});
	// exports all packages
	m.descriptor.packages().forEach(builder::exports);
	m.descriptor.uses().forEach(builder::uses);
	m.descriptor.provides().forEach(builder::provides);
	this.md = builder.build();
	}

	@Override
	public ModuleDescriptor descriptor() {
	return md;
	}
	}
	}