38 * 2. -filter:package to filter out same-package dependencies
39 * This filter is applied when jdeps parses the class files
40 * and filtered dependencies are not stored in the Analyzer.
41 * 3. --require specifies to match target dependence from the given module
42 * This gets expanded into package lists to be filtered.
43 * 4. -filter:archive to filter out same-archive dependencies
44 * This filter is applied later in the Analyzer as the
45 * containing archive of a target class may not be known until
46 * the entire archive
47 */
48 public class JdepsFilter implements Dependency.Filter, Analyzer.Filter {
49
50 public static final JdepsFilter DEFAULT_FILTER =
51 new JdepsFilter.Builder().filter(true, true).build();
52
53 private final Dependency.Filter filter;
54 private final Pattern filterPattern;
55 private final boolean filterSamePackage;
56 private final boolean filterSameArchive;
57 private final boolean findJDKInternals;
58 private final Pattern includePattern;
59
60 private final Set<String> requires;
61
62 private JdepsFilter(Dependency.Filter filter,
63 Pattern filterPattern,
64 boolean filterSamePackage,
65 boolean filterSameArchive,
66 boolean findJDKInternals,
67 Pattern includePattern,
68 Set<String> requires) {
69 this.filter = filter;
70 this.filterPattern = filterPattern;
71 this.filterSamePackage = filterSamePackage;
72 this.filterSameArchive = filterSameArchive;
73 this.findJDKInternals = findJDKInternals;
74 this.includePattern = includePattern;
75 this.requires = requires;
76 }
77
78 /**
79 * Tests if the given class matches the pattern given in the -include option
80 *
81 * @param cn fully-qualified name
82 */
83 public boolean matches(String cn) {
84 if (includePattern == null)
85 return true;
86
87 if (includePattern != null)
88 return includePattern.matcher(cn).matches();
89
90 return false;
91 }
92
93 /**
136 return false;
137 }
138
139 // filter if the target matches the given filtered package name or regex
140 return filter != null ? filter.accepts(d) : true;
141 }
142
143 // ----- Analyzer.Filter ------
144
145 /**
146 * Filter depending on the containing archive or module
147 */
148 @Override
149 public boolean accepts(Location origin, Archive originArchive,
150 Location target, Archive targetArchive) {
151 if (findJDKInternals) {
152 // accepts target that is JDK class but not exported
153 Module module = targetArchive.getModule();
154 return originArchive != targetArchive &&
155 isJDKInternalPackage(module, target.getPackageName());
156 } else if (filterSameArchive) {
157 // accepts origin and target that from different archive
158 return originArchive != targetArchive;
159 }
160 return true;
161 }
162
163 /**
164 * Tests if the package is an internal package of the given module.
165 */
166 public boolean isJDKInternalPackage(Module module, String pn) {
167 if (module.isJDKUnsupported()) {
168 // its exported APIs are unsupported
169 return true;
170 }
171
172 return module.isJDK() && !module.isExported(pn);
173 }
174
175 @Override
176 public String toString() {
177 StringBuilder sb = new StringBuilder();
178 sb.append("include pattern: ").append(includePattern).append("\n");
179 sb.append("filter same archive: ").append(filterSameArchive).append("\n");
180 sb.append("filter same package: ").append(filterSamePackage).append("\n");
181 sb.append("requires: ").append(requires).append("\n");
182 return sb.toString();
183 }
184
185 public static class Builder {
186 Pattern filterPattern;
187 Pattern regex;
188 boolean filterSamePackage;
189 boolean filterSameArchive;
190 boolean findJDKInterals;
191 // source filters
192 Pattern includePattern;
193 Set<String> requires = new HashSet<>();
194 Set<String> targetPackages = new HashSet<>();
195
196 public Builder() {};
197
198 public Builder packages(Set<String> packageNames) {
199 this.targetPackages.addAll(packageNames);
200 return this;
201 }
202 public Builder regex(Pattern regex) {
203 this.regex = regex;
204 return this;
205 }
206 public Builder filter(Pattern regex) {
207 this.filterPattern = regex;
208 return this;
209 }
210 public Builder filter(boolean samePackage, boolean sameArchive) {
211 this.filterSamePackage = samePackage;
212 this.filterSameArchive = sameArchive;
213 return this;
214 }
215 public Builder requires(String name, Set<String> packageNames) {
216 this.requires.add(name);
217 this.targetPackages.addAll(packageNames);
218 return this;
219 }
220 public Builder findJDKInternals(boolean value) {
221 this.findJDKInterals = value;
222 return this;
223 }
224 public Builder includePattern(Pattern regex) {
225 this.includePattern = regex;
226 return this;
227 }
228
229 public JdepsFilter build() {
230 Dependency.Filter filter = null;
231 if (regex != null)
232 filter = Dependencies.getRegexFilter(regex);
233 else if (!targetPackages.isEmpty()) {
234 filter = Dependencies.getPackageFilter(targetPackages, false);
235 }
236 return new JdepsFilter(filter,
237 filterPattern,
238 filterSamePackage,
239 filterSameArchive,
240 findJDKInterals,
241 includePattern,
242 requires);
243 }
244
245 }
246 }
|
38 * 2. -filter:package to filter out same-package dependencies
39 * This filter is applied when jdeps parses the class files
40 * and filtered dependencies are not stored in the Analyzer.
41 * 3. --require specifies to match target dependence from the given module
42 * This gets expanded into package lists to be filtered.
43 * 4. -filter:archive to filter out same-archive dependencies
44 * This filter is applied later in the Analyzer as the
45 * containing archive of a target class may not be known until
46 * the entire archive
47 */
48 public class JdepsFilter implements Dependency.Filter, Analyzer.Filter {
49
50 public static final JdepsFilter DEFAULT_FILTER =
51 new JdepsFilter.Builder().filter(true, true).build();
52
53 private final Dependency.Filter filter;
54 private final Pattern filterPattern;
55 private final boolean filterSamePackage;
56 private final boolean filterSameArchive;
57 private final boolean findJDKInternals;
58 private final boolean findMissingDeps;
59 private final Pattern includePattern;
60
61 private final Set<String> requires;
62
63 private JdepsFilter(Dependency.Filter filter,
64 Pattern filterPattern,
65 boolean filterSamePackage,
66 boolean filterSameArchive,
67 boolean findJDKInternals,
68 boolean findMissingDeps,
69 Pattern includePattern,
70 Set<String> requires) {
71 this.filter = filter;
72 this.filterPattern = filterPattern;
73 this.filterSamePackage = filterSamePackage;
74 this.filterSameArchive = filterSameArchive;
75 this.findJDKInternals = findJDKInternals;
76 this.findMissingDeps = findMissingDeps;
77 this.includePattern = includePattern;
78 this.requires = requires;
79 }
80
81 /**
82 * Tests if the given class matches the pattern given in the -include option
83 *
84 * @param cn fully-qualified name
85 */
86 public boolean matches(String cn) {
87 if (includePattern == null)
88 return true;
89
90 if (includePattern != null)
91 return includePattern.matcher(cn).matches();
92
93 return false;
94 }
95
96 /**
139 return false;
140 }
141
142 // filter if the target matches the given filtered package name or regex
143 return filter != null ? filter.accepts(d) : true;
144 }
145
146 // ----- Analyzer.Filter ------
147
148 /**
149 * Filter depending on the containing archive or module
150 */
151 @Override
152 public boolean accepts(Location origin, Archive originArchive,
153 Location target, Archive targetArchive) {
154 if (findJDKInternals) {
155 // accepts target that is JDK class but not exported
156 Module module = targetArchive.getModule();
157 return originArchive != targetArchive &&
158 isJDKInternalPackage(module, target.getPackageName());
159 } else if (findMissingDeps) {
160 return Analyzer.notFound(targetArchive);
161 } else if (filterSameArchive) {
162 // accepts origin and target that from different archive
163 return originArchive != targetArchive;
164 }
165 return true;
166 }
167
168 /**
169 * Tests if the package is an internal package of the given module.
170 */
171 public boolean isJDKInternalPackage(Module module, String pn) {
172 if (module.isJDKUnsupported()) {
173 // its exported APIs are unsupported
174 return true;
175 }
176
177 return module.isJDK() && !module.isExported(pn);
178 }
179
180 @Override
181 public String toString() {
182 StringBuilder sb = new StringBuilder();
183 sb.append("include pattern: ").append(includePattern).append("\n");
184 sb.append("filter same archive: ").append(filterSameArchive).append("\n");
185 sb.append("filter same package: ").append(filterSamePackage).append("\n");
186 sb.append("requires: ").append(requires).append("\n");
187 return sb.toString();
188 }
189
190 public static class Builder {
191 Pattern filterPattern;
192 Pattern regex;
193 boolean filterSamePackage;
194 boolean filterSameArchive;
195 boolean findJDKInterals;
196 boolean findMissingDeps;
197 // source filters
198 Pattern includePattern;
199 Set<String> requires = new HashSet<>();
200 Set<String> targetPackages = new HashSet<>();
201
202 public Builder() {};
203
204 public Builder packages(Set<String> packageNames) {
205 this.targetPackages.addAll(packageNames);
206 return this;
207 }
208 public Builder regex(Pattern regex) {
209 this.regex = regex;
210 return this;
211 }
212 public Builder filter(Pattern regex) {
213 this.filterPattern = regex;
214 return this;
215 }
216 public Builder filter(boolean samePackage, boolean sameArchive) {
217 this.filterSamePackage = samePackage;
218 this.filterSameArchive = sameArchive;
219 return this;
220 }
221 public Builder requires(String name, Set<String> packageNames) {
222 this.requires.add(name);
223 this.targetPackages.addAll(packageNames);
224 return this;
225 }
226 public Builder findJDKInternals(boolean value) {
227 this.findJDKInterals = value;
228 return this;
229 }
230 public Builder findMissingDeps(boolean value) {
231 this.findMissingDeps = value;
232 return this;
233 }
234 public Builder includePattern(Pattern regex) {
235 this.includePattern = regex;
236 return this;
237 }
238
239 public JdepsFilter build() {
240 Dependency.Filter filter = null;
241 if (regex != null)
242 filter = Dependencies.getRegexFilter(regex);
243 else if (!targetPackages.isEmpty()) {
244 filter = Dependencies.getPackageFilter(targetPackages, false);
245 }
246 return new JdepsFilter(filter,
247 filterPattern,
248 filterSamePackage,
249 filterSameArchive,
250 findJDKInterals,
251 findMissingDeps,
252 includePattern,
253 requires);
254 }
255
256 }
257 }
|