181 public static List<PackageElement>
182 packagesIn(Iterable<? extends Element> elements) {
183 return listFilter(elements, PACKAGE_KIND, PackageElement.class);
184 }
185
186 /**
187 * Returns a set of packages in {@code elements}.
188 * @return a set of packages in {@code elements}
189 * @param elements the elements to filter
190 */
191 public static Set<PackageElement>
192 packagesIn(Set<? extends Element> elements) {
193 return setFilter(elements, PACKAGE_KIND, PackageElement.class);
194 }
195
196 /**
197 * Returns a list of modules in {@code elements}.
198 * @return a list of modules in {@code elements}
199 * @param elements the elements to filter
200 * @since 9
201 */
202 public static List<ModuleElement>
203 modulesIn(Iterable<? extends Element> elements) {
204 return listFilter(elements, MODULE_KIND, ModuleElement.class);
205 }
206
207 /**
208 * Returns a set of modules in {@code elements}.
209 * @return a set of modules in {@code elements}
210 * @param elements the elements to filter
211 * @since 9
212 */
213 public static Set<ModuleElement>
214 modulesIn(Set<? extends Element> elements) {
215 return setFilter(elements, MODULE_KIND, ModuleElement.class);
216 }
217
218 // Assumes targetKinds and E are sensible.
219 private static <E extends Element> List<E> listFilter(Iterable<? extends Element> elements,
220 Set<ElementKind> targetKinds,
221 Class<E> clazz) {
222 List<E> list = new ArrayList<>();
223 for (Element e : elements) {
224 if (targetKinds.contains(e.getKind()))
225 list.add(clazz.cast(e));
226 }
227 return list;
228 }
229
230 // Assumes targetKinds and E are sensible.
231 private static <E extends Element> Set<E> setFilter(Set<? extends Element> elements,
232 Set<ElementKind> targetKinds,
233 Class<E> clazz) {
234 // Return set preserving iteration order of input set.
235 Set<E> set = new LinkedHashSet<>();
236 for (Element e : elements) {
237 if (targetKinds.contains(e.getKind()))
238 set.add(clazz.cast(e));
239 }
240 return set;
241 }
242
243 /**
244 * Returns a list of {@code exports} directives in {@code directives}.
245 * @return a list of {@code exports} directives in {@code directives}
246 * @param directives the directives to filter
247 * @since 9
248 */
249 public static List<ExportsDirective>
250 exportsIn(Iterable<? extends Directive> directives) {
251 return listFilter(directives, DirectiveKind.EXPORTS, ExportsDirective.class);
252 }
253
254 /**
255 * Returns a list of {@code opens} directives in {@code directives}.
256 * @return a list of {@code opens} directives in {@code directives}
257 * @param directives the directives to filter
258 * @since 9
259 */
260 public static List<OpensDirective>
261 opensIn(Iterable<? extends Directive> directives) {
262 return listFilter(directives, DirectiveKind.OPENS, OpensDirective.class);
263 }
264
265 /**
266 * Returns a list of {@code provides} directives in {@code directives}.
267 * @return a list of {@code provides} directives in {@code directives}
268 * @param directives the directives to filter
269 * @since 9
270 */
271 public static List<ProvidesDirective>
272 providesIn(Iterable<? extends Directive> directives) {
273 return listFilter(directives, DirectiveKind.PROVIDES, ProvidesDirective.class);
274 }
275
276 /**
277 * Returns a list of {@code requires} directives in {@code directives}.
278 * @return a list of {@code requires} directives in {@code directives}
279 * @param directives the directives to filter
280 * @since 9
281 */
282 public static List<RequiresDirective>
283 requiresIn(Iterable<? extends Directive> directives) {
284 return listFilter(directives, DirectiveKind.REQUIRES, RequiresDirective.class);
285 }
286
287 /**
288 * Returns a list of {@code uses} directives in {@code directives}.
289 * @return a list of {@code uses} directives in {@code directives}
290 * @param directives the directives to filter
291 * @since 9
292 */
293 public static List<UsesDirective>
294 usesIn(Iterable<? extends Directive> directives) {
295 return listFilter(directives, DirectiveKind.USES, UsesDirective.class);
296 }
297
298 // Assumes directiveKind and D are sensible.
299 private static <D extends Directive> List<D> listFilter(Iterable<? extends Directive> directives,
300 DirectiveKind directiveKind,
301 Class<D> clazz) {
302 List<D> list = new ArrayList<>();
303 for (Directive d : directives) {
304 if (d.getKind() == directiveKind)
305 list.add(clazz.cast(d));
306 }
307 return list;
308 }
309 }
|
181 public static List<PackageElement>
182 packagesIn(Iterable<? extends Element> elements) {
183 return listFilter(elements, PACKAGE_KIND, PackageElement.class);
184 }
185
186 /**
187 * Returns a set of packages in {@code elements}.
188 * @return a set of packages in {@code elements}
189 * @param elements the elements to filter
190 */
191 public static Set<PackageElement>
192 packagesIn(Set<? extends Element> elements) {
193 return setFilter(elements, PACKAGE_KIND, PackageElement.class);
194 }
195
196 /**
197 * Returns a list of modules in {@code elements}.
198 * @return a list of modules in {@code elements}
199 * @param elements the elements to filter
200 * @since 9
201 * @spec JPMS
202 */
203 public static List<ModuleElement>
204 modulesIn(Iterable<? extends Element> elements) {
205 return listFilter(elements, MODULE_KIND, ModuleElement.class);
206 }
207
208 /**
209 * Returns a set of modules in {@code elements}.
210 * @return a set of modules in {@code elements}
211 * @param elements the elements to filter
212 * @since 9
213 * @spec JPMS
214 */
215 public static Set<ModuleElement>
216 modulesIn(Set<? extends Element> elements) {
217 return setFilter(elements, MODULE_KIND, ModuleElement.class);
218 }
219
220 // Assumes targetKinds and E are sensible.
221 private static <E extends Element> List<E> listFilter(Iterable<? extends Element> elements,
222 Set<ElementKind> targetKinds,
223 Class<E> clazz) {
224 List<E> list = new ArrayList<>();
225 for (Element e : elements) {
226 if (targetKinds.contains(e.getKind()))
227 list.add(clazz.cast(e));
228 }
229 return list;
230 }
231
232 // Assumes targetKinds and E are sensible.
233 private static <E extends Element> Set<E> setFilter(Set<? extends Element> elements,
234 Set<ElementKind> targetKinds,
235 Class<E> clazz) {
236 // Return set preserving iteration order of input set.
237 Set<E> set = new LinkedHashSet<>();
238 for (Element e : elements) {
239 if (targetKinds.contains(e.getKind()))
240 set.add(clazz.cast(e));
241 }
242 return set;
243 }
244
245 /**
246 * Returns a list of {@code exports} directives in {@code directives}.
247 * @return a list of {@code exports} directives in {@code directives}
248 * @param directives the directives to filter
249 * @since 9
250 * @spec JPMS
251 */
252 public static List<ExportsDirective>
253 exportsIn(Iterable<? extends Directive> directives) {
254 return listFilter(directives, DirectiveKind.EXPORTS, ExportsDirective.class);
255 }
256
257 /**
258 * Returns a list of {@code opens} directives in {@code directives}.
259 * @return a list of {@code opens} directives in {@code directives}
260 * @param directives the directives to filter
261 * @since 9
262 */
263 public static List<OpensDirective>
264 opensIn(Iterable<? extends Directive> directives) {
265 return listFilter(directives, DirectiveKind.OPENS, OpensDirective.class);
266 }
267
268 /**
269 * Returns a list of {@code provides} directives in {@code directives}.
270 * @return a list of {@code provides} directives in {@code directives}
271 * @param directives the directives to filter
272 * @since 9
273 * @spec JPMS
274 */
275 public static List<ProvidesDirective>
276 providesIn(Iterable<? extends Directive> directives) {
277 return listFilter(directives, DirectiveKind.PROVIDES, ProvidesDirective.class);
278 }
279
280 /**
281 * Returns a list of {@code requires} directives in {@code directives}.
282 * @return a list of {@code requires} directives in {@code directives}
283 * @param directives the directives to filter
284 * @since 9
285 * @spec JPMS
286 */
287 public static List<RequiresDirective>
288 requiresIn(Iterable<? extends Directive> directives) {
289 return listFilter(directives, DirectiveKind.REQUIRES, RequiresDirective.class);
290 }
291
292 /**
293 * Returns a list of {@code uses} directives in {@code directives}.
294 * @return a list of {@code uses} directives in {@code directives}
295 * @param directives the directives to filter
296 * @since 9
297 * @spec JPMS
298 */
299 public static List<UsesDirective>
300 usesIn(Iterable<? extends Directive> directives) {
301 return listFilter(directives, DirectiveKind.USES, UsesDirective.class);
302 }
303
304 // Assumes directiveKind and D are sensible.
305 private static <D extends Directive> List<D> listFilter(Iterable<? extends Directive> directives,
306 DirectiveKind directiveKind,
307 Class<D> clazz) {
308 List<D> list = new ArrayList<>();
309 for (Directive d : directives) {
310 if (d.getKind() == directiveKind)
311 list.add(clazz.cast(d));
312 }
313 return list;
314 }
315 }
|