1 /*
2 * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25 package com.sun.tools.jdeps;
26
27 import java.util.Collections;
28 import java.util.HashMap;
29 import java.util.HashSet;
30 import java.util.Map;
31 import java.util.Objects;
32 import java.util.Set;
33
34 /**
35 * JDeps internal representation of module for dependency analysis.
36 */
37 final class Module extends Archive {
38 private final String moduleName;
39 private final Map<String, Boolean> requires;
40 private final Map<String, Set<String>> exports;
41 private final Set<String> packages;
42
43 private Module(ClassFileReader reader, String name,
44 Map<String, Boolean> requires,
45 Map<String, Set<String>> exports,
46 Set<String> packages) {
47 super(name, reader);
48 this.moduleName = name;
49 this.requires = Collections.unmodifiableMap(requires);
50 this.exports = Collections.unmodifiableMap(exports);
51 this.packages = Collections.unmodifiableSet(packages);
52 }
53
54 public String name() {
55 return moduleName;
56 }
57
58 public Map<String, Boolean> requires() {
59 return requires;
60 }
61
62 public Map<String, Set<String>> exports() {
63 return exports;
64 }
65
66 public Set<String> packages() {
67 return packages;
68 }
69
70 /**
71 * Tests if this module can read m
72 */
73 public boolean canRead(Module m) {
74 // ## TODO: handle "re-exported=true"
75 // all JDK modules require all modules containing its direct dependences
76 // should not be an issue
77 return requires.containsKey(m.name());
78 }
79
80 /**
81 * Tests if a given fully-qualified name is an exported type.
82 */
83 public boolean isExported(String cn) {
84 int i = cn.lastIndexOf('.');
85 String pn = i > 0 ? cn.substring(0, i) : "";
86
87 return isExportedPackage(pn);
88 }
89
90 /**
91 * Tests if a given package name is exported.
92 */
93 public boolean isExportedPackage(String pn) {
94 return exports.containsKey(pn) ? exports.get(pn).isEmpty() : false;
95 }
96
97 /**
98 * Tests if the given classname is accessible to module m
99 */
100 public boolean isAccessibleTo(String classname, Module m) {
101 int i = classname.lastIndexOf('.');
102 String pn = i > 0 ? classname.substring(0, i) : "";
103 if (!packages.contains(pn)) {
104 throw new IllegalArgumentException(classname + " is not a member of module " + name());
105 }
106
107 if (m != null && !m.canRead(this)) {
108 trace("%s not readable by %s%n", this.name(), m.name());
109 return false;
110 }
111
112 // exported API
113 Set<String> ms = exports().get(pn);
114 String mname = m != null ? m.name() : "unnamed";
115 if (ms == null) {
116 trace("%s not exported in %s%n", classname, this.name());
117 } else if (!(ms.isEmpty() || ms.contains(mname))) {
118 trace("%s not permit to %s %s%n", classname, mname, ms);
119 }
120 return ms != null && (ms.isEmpty() || ms.contains(mname));
121 }
122
123 private static final boolean traceOn = Boolean.getBoolean("jdeps.debug");
124 private void trace(String fmt, Object... args) {
125 if (traceOn) {
126 System.err.format(fmt, args);
127 }
128 }
129
130 @Override
131 public boolean equals(Object ob) {
132 if (!(ob instanceof Module))
133 return false;
134 Module that = (Module)ob;
135 return (moduleName.equals(that.moduleName)
136 && requires.equals(that.requires)
137 && exports.equals(that.exports)
138 && packages.equals(that.packages));
139 }
140
141 @Override
142 public int hashCode() {
143 int hc = moduleName.hashCode();
144 hc = hc * 43 + requires.hashCode();
145 hc = hc * 43 + exports.hashCode();
146 hc = hc * 43 + packages.hashCode();
147 return hc;
148 }
149
150 @Override
151 public String toString() {
152 return name();
153 }
154
155 public final static class Builder {
156 String name;
157 ClassFileReader reader;
158 final Map<String, Boolean> requires = new HashMap<>();
159 final Map<String, Set<String>> exports = new HashMap<>();
160 final Set<String> packages = new HashSet<>();
161
162 public Builder() {
163 }
164
165 public Builder name(String n) {
166 name = n;
167 return this;
168 }
169
170 public Builder require(String d, boolean reexport) {
171 // System.err.format("%s depend %s reexports %s%n", name, d, reexport);
172 requires.put(d, reexport);
173 return this;
174 }
175
176 public Builder packages(Set<String> pkgs) {
177 packages.addAll(pkgs);
178 return this;
179 }
180
181 public Builder export(String p, Set<String> ms) {
182 Objects.requireNonNull(p);
183 Objects.requireNonNull(ms);
184 exports.put(p, new HashSet<>(ms));
185 return this;
186 }
187 public Builder classes(ClassFileReader.ModuleClassReader reader) {
188 this.reader = reader;
189 return this;
190 }
191
192 public Module build() {
193 Module m = new Module(reader, name, requires, exports, packages);
194 return m;
195 }
196 }
197 }