private Map<String, String> getAllDocStrings0(ClassLoader classLoader) { final Configuration configuration = new ConfigurationBuilder() .filterInputsBy(new FilterBuilder().includePackage(path)) .setUrls(ClasspathHelper.forPackage(path, classLoader)) .addClassLoader(classLoader) .setScanners(new ResourcesScanner()); if (configuration.getUrls() == null || configuration.getUrls().isEmpty()) { return Collections.emptyMap(); } final Map<String, byte[]> files = new Reflections(configuration) .getResources(this::acceptFile).stream() .map(f -> { try { URL url = classLoader.getResource(f); if (url == null) { throw new IllegalStateException("not found: " + f); } return new SimpleImmutableEntry<>(f, Resources.toByteArray(url)); } catch (IOException e) { throw new UncheckedIOException(e); } }) .collect(toImmutableMap(Entry::getKey, Entry::getValue)); return getDocStringsFromFiles(files); }
SubTypesScanner subTypesScanner = new SubTypesScanner(parentResult.getImplementations()); if (packagePrefixes.size() > 0) { final FilterBuilder filter = new FilterBuilder(); for (String prefix : packagePrefixes) { filter.include(FilterBuilder.prefix(prefix)); ConfigurationBuilder conf = new ConfigurationBuilder() .setUrls(pathsToScan) .setMetadataAdapter(METADATA_ADAPTER) // Scanners depend on this .filterInputsBy(filter) .setScanners(annotationScanner, subTypesScanner); new Reflections(conf);
ConfigurationBuilder config = new ConfigurationBuilder(); Set<String> acceptablePackages = new HashSet<String>(); Set<Class<?>> output = new HashSet<Class<?>>(); if (!isIgnored(pkg)) { acceptablePackages.add(pkg); config.addUrls(ClasspathHelper.forPackage(pkg)); allowAllPackages = true; config.filterInputsBy(new FilterBuilder().exclude(".*json").exclude(".*yaml")); config.setScanners(new ResourcesScanner(), new TypeAnnotationsScanner(), new SubTypesScanner()); final Reflections reflections; reflections = new Reflections(config); Set<Class<?>> classes = reflections.getTypesAnnotatedWith(javax.ws.rs.Path.class); classes.addAll(reflections.getTypesAnnotatedWith(OpenAPIDefinition.class));
/** collect saved Reflection xml resources and merge it into a Reflections instance * <p>by default, resources are collected from all urls that contains the package META-INF/reflections * and includes files matching the pattern .*-reflections.xml * */ public static Reflections collect() { return collect("META-INF/reflections/", new FilterBuilder().include(".*-reflections.xml")); }
/** created new SubTypesScanner. * @param excludeObjectClass if false, include direct {@link Object} subtypes in results. */ public SubTypesScanner(boolean excludeObjectClass) { if (excludeObjectClass) { filterResultsBy(new FilterBuilder().exclude(Object.class.getName())); //exclude direct Object subtypes } }
private Reflections createReflections() { Configuration config = new ConfigurationBuilder() .setScanners(new SubTypesScanner()) .addUrls(ClasspathHelper.getUrls()) .filterInputsBy(new FilterBuilder().include(".+\\.class")); return new Reflections(config); }
public DefaultOpFactory() { opClazzes = new HashMap<>(); Reflections f = new Reflections(new ConfigurationBuilder().filterInputsBy( new FilterBuilder().include(FilterBuilder.prefix("org.nd4j")).exclude("^(?!.*\\.class$).*$") //Consider only .class files (to avoid debug messages etc. on .dlls, etc .exclude("^(?!org\\.nd4j\\.linalg\\.api\\.ops).*") //Exclude any not in the ops directory ) .setUrls(ClasspathHelper.forPackage("org.nd4j")).setScanners(new SubTypesScanner())); Set<Class<? extends Op>> clazzes = f.getSubTypesOf(Op.class); for (Class<? extends Op> clazz : clazzes) { if (Modifier.isAbstract(clazz.getModifiers()) || clazz.isInterface()) continue; try { opClazzes.put(clazz.newInstance().name(), clazz); } catch (Exception e) { throw new RuntimeException(e); } } }
/** * Scan the classpath for {@link #classpathRootName} and return all resources under it. * {@inheritDoc} * @see org.apache.gobblin.config.store.deploy.DeployableConfigSource#getDeployableConfigPaths() */ private Set<String> getDeployableConfigPaths() { ConfigurationBuilder cb = new ConfigurationBuilder().setUrls(ClasspathHelper.forClassLoader()).setScanners(new ResourcesScanner()) .filterInputsBy(new FilterBuilder().include(String.format(".*%s.*", this.classpathRootName))); Reflections reflections = new Reflections(cb); Pattern pattern = Pattern.compile(".*"); return reflections.getResources(pattern); }
private static Reflections createReflections() { List<ClassLoader> classLoadersList = new LinkedList<>(); classLoadersList.add(ClasspathHelper.contextClassLoader()); classLoadersList.add(ClasspathHelper.staticClassLoader()); return new Reflections(new ConfigurationBuilder() .setScanners(new SubTypesScanner(false /* don't exclude Object.class */), new ResourcesScanner()) .setUrls(ClasspathHelper.forManifest(ClasspathHelper.forClassLoader( classLoadersList.toArray(new ClassLoader[classLoadersList.size()])))) .filterInputsBy(new FilterBuilder().include(FilterBuilder.prefix("com.kakao.hbase.manager.command")))); }
static Reflections reflections() { final Reflections cached = reflector; if (cached != null) return cached; final Reflections newInstance = new Reflections(new ConfigurationBuilder() .setUrls(ClasspathHelper.forPackage("org.intellivim")) .setScanners( new SubTypesScanner(), new TypeAnnotationsScanner()) .filterInputsBy(new FilterBuilder().include("org.intellivim.*")) ); reflector = newInstance; return newInstance; }
public Set<Class<?>> discover(String packagePrefix) { Reflections reflections = new Reflections(new ConfigurationBuilder() .setUrls(ClasspathHelper.forPackage(packagePrefix)) .filterInputsBy(new FilterBuilder().includePackage(packagePrefix)) ); return reflections.getTypesAnnotatedWith(DRGElement.class); } }
@TaskAction public void generateSpec() throws IOException, GenerateException { ClassLoader loader = projectClassLoader(); Set<Class<?>> classes = new HashSet<>(); for (String pkg : apiPackages) { Reflections reflections = new Reflections( new ConfigurationBuilder() .addClassLoaders(loader) .addUrls(ClasspathHelper.forPackage(pkg, loader)) .setExpandSuperTypes(false) .filterInputsBy(new FilterBuilder().includePackage(pkg))); Set<Class<?>> springMVCClasses = reflections.getTypesAnnotatedWith( org.springframework.web.bind.annotation.RestController.class); classes.addAll(springMVCClasses); } SpringMvcApiReader reader = new SpringMvcApiReader(new Swagger(), log); Swagger swagger = reader.read(classes); for (SwaggerFilter filter : filters) { filter.apply(swagger); } Yaml.pretty().writeValue(swaggerFile, swagger); }
public Collection<TestConfiguration> generateData(String testPackage, String pattern) { Reflections reflections = new Reflections(new ConfigurationBuilder().setScanners(new ResourcesScanner()) .setUrls(ClasspathHelper.forPackage("")) .filterInputsBy(new FilterBuilder.Include(FilterBuilder.prefix(testPackage)))); Collection<TestConfiguration> data = new ArrayList<TestConfiguration>(); for (String testResourceName : reflections.getResources(Pattern.compile(pattern))) { data.addAll(parseSingleResource(testResourceName)); } return data; }
List<Class<?>> classesList = Arrays.<Class<?>>asList(Layer.class, GraphVertex.class); Collection<URL> urls = ClasspathHelper.forClassLoader(); List<URL> scanUrls = new ArrayList<>(); for (URL u : urls) { Reflections reflections = new Reflections(new ConfigurationBuilder().filterInputsBy(new FilterBuilder() .exclude("^(?!.*\\.class$).*$") //Consider only .class files (to avoid debug messages etc. on .dlls, etc .exclude("^org.nd4j.*").exclude("^org.datavec.*").exclude("^org.bytedeco.*") //JavaCPP .exclude("^com.fasterxml.*")//Jackson .exclude("^org.apache.*") //Apache commons, Spark, log4j etc .exclude("^org.projectlombok.*").exclude("^com.twelvemonkeys.*").exclude("^org.joda.*") .exclude("^org.slf4j.*").exclude("^com.google.*").exclude("^org.reflections.*") .exclude("^ch.qos.*") //Logback ).addUrls(scanUrls).setScanners(new DL4JSubTypesScanner(interfaces, classesList))); org.reflections.Store store = reflections.getStore();
/** * Get all the entities in a package. * * @param packageName Package name * @return All entities found in package. */ public static HashSet<Class> getAllEntities(String packageName) { return new HashSet<>(new Reflections(new ConfigurationBuilder() .setScanners(new SubTypesScanner(false), new TypeAnnotationsScanner()) .setUrls(ClasspathHelper.forClassLoader(ClassLoader.getSystemClassLoader())) .filterInputsBy(new FilterBuilder().include(FilterBuilder.prefix(packageName)))) .getTypesAnnotatedWith(Entity.class)); } }
/** * @since 2.5RC1 */ public RenderingTestSuite(String name, String testPackage, String pattern) { super(name); Reflections reflections = new Reflections(new ConfigurationBuilder() .setScanners(new ResourcesScanner()) .setUrls(ClasspathHelper.getUrlsForPackagePrefix("")) .filterInputsBy(new FilterBuilder.Include(FilterBuilder.prefix(testPackage)))); for (String testFile : reflections.getResources(Pattern.compile(pattern))) { addTestsFromResource(testFile); } }
FilterBuilder filter = new FilterBuilder(); urls.addAll(ClasspathHelper.forPackage(pkg)); filter.includePackage(pkg); reflections = new Reflections(new ConfigurationBuilder().filterInputsBy(filter).setUrls(urls).addScanners(new MethodAnnotationsScanner()));
@Override public Collection<Class<? extends T>> lookup(Class<?> clazz, ClassLoader classLoader) { Reflections reflections = new Reflections(new ConfigurationBuilder() .addClassLoader(classLoader) .setUrls(ClasspathHelper.forClass(clazz, classLoader)) .setScanners(new SubTypesScanner(true), new TypeAnnotationsScanner()) .filterInputsBy(new FilterBuilder().includePackage(clazz.getPackage().getName()))); return reflections.getSubTypesOf(subType); } }
private static Set<Class<?>> findObjectMappers() { final Predicate<String> filter = new Predicate<String>() { @Override public boolean apply(final String input) { return GlobalObjectMapper.class.getCanonicalName().equals(input); } }; final String myNameSpaceToScan = getNameSpace(); final Reflections reflections = new Reflections(new ConfigurationBuilder().filterInputsBy( new FilterBuilder.Include(FilterBuilder.prefix(myNameSpaceToScan))).setUrls( ClasspathHelper.forPackage(myNameSpaceToScan)).setScanners(new TypeAnnotationsScanner() .filterResultsBy(filter), new SubTypesScanner())); final Set<Class<?>> objectMapper = reflections.getTypesAnnotatedWith(GlobalObjectMapper.class); return objectMapper; }