s.addAll(ClasspathHelper.forJavaClassPath()); final Iterator<URL> iterator = s.iterator(); while (iterator.hasNext()) {
urls = ClasspathHelper.forJavaClassPath(); classPool = ClassPool.getDefault(); } else {
@Override @SuppressWarnings("unchecked") public Set<Class> load(Class key) throws Exception { Reflections reflections = new Reflections(forJavaClassPath()); return reflections.getSubTypesOf(key); } });
public static Collection<URL> getUrls() { final String packagesToScan = System.getenv(GaugeConstant.PACKAGE_TO_SCAN); if (packagesToScan != null) { Collection<URL> urls = new ArrayList<>(); final List<String> packages = Arrays.asList(packagesToScan.split(",")); for (String packageToScan : packages) { urls.addAll(org.reflections.util.ClasspathHelper.forPackage(packageToScan.trim())); } return urls; } return org.reflections.util.ClasspathHelper.forJavaClassPath(); }
public static Collection<URL> getUrls() { final String packagesToScan = System.getenv(GaugeConstant.PACKAGE_TO_SCAN); if (packagesToScan != null) { Collection<URL> urls = new ArrayList<>(); final List<String> packages = Arrays.asList(packagesToScan.split(",")); for (String packageToScan : packages) { urls.addAll(org.reflections.util.ClasspathHelper.forPackage(packageToScan.trim())); } return urls; } return org.reflections.util.ClasspathHelper.forJavaClassPath(); }
private List<String> getClasspath() { List<String> urls = new ArrayList<String>(); if (classpathUrls != null) { for (URL classpathUrl : classpathUrls) { urls.add(classpathUrl.toExternalForm()); } } else { Set<URL> coreClasspathUrls = new HashSet<URL>(); coreClasspathUrls.addAll(ClasspathHelper.forJavaClassPath()); coreClasspathUrls.addAll(ClasspathHelper.forClassLoader()); for (URL coreClasspathUrl : coreClasspathUrls) { urls.add(coreClasspathUrl.toExternalForm()); } } return urls; }
@Override public Set<Field> load(Class<? extends Annotation> key) throws Exception { Reflections reflections = new Reflections(forJavaClassPath(), new FieldAnnotationsScanner(), ReflectionHelper.class.getClassLoader()); return unmodifiableSet(reflections.getFieldsAnnotatedWith(key)); } });
allUrls.addAll(ClasspathHelper.forJavaClassPath());
private ConfigurationBuilder createConfigurationBuilder() { final ConfigurationBuilder configurationBuilder = new ConfigurationBuilder(); configurationBuilder.setUrls(ClasspathHelper.forJavaClassPath()); if (parallelExecutors) return configurationBuilder.useParallelExecutor(); else return configurationBuilder; }
private void initPluginLoader(String path) { try { if (CLASSPATH_NAME.equals(path)) { scanUrlsAndAddPlugins( getParent(), ClasspathHelper.forJavaClassPath().toArray(new URL[0]), null ); } else { Path pluginPath = Paths.get(path).toAbsolutePath(); // Update for exception handling path = pluginPath.toString(); // Currently 'plugin.paths' property is a list of top-level directories // containing plugins if (Files.isDirectory(pluginPath)) { for (Path pluginLocation : PluginUtils.pluginLocations(pluginPath)) { registerPlugin(pluginLocation); } } else if (PluginUtils.isArchive(pluginPath)) { registerPlugin(pluginPath); } } } catch (InvalidPathException | MalformedURLException e) { log.error("Invalid path in plugin path: {}. Ignoring.", path, e); } catch (IOException e) { log.error("Could not get listing for plugin path: {}. Ignoring.", path, e); } catch (InstantiationException | IllegalAccessException e) { log.error("Could not instantiate plugins in: {}. Ignoring: {}", path, e); } }
/** * Initialize the pluginsIdMap. Find all the subtypes of {@link OpenCGAAnalysis} */ private void init() { // Reflections.log = null; // Uncomment to skip logs reflections = new Reflections(new ConfigurationBuilder() .setScanners(new SubTypesScanner()).addUrls(ClasspathHelper.forJavaClassPath()) .filterInputsBy(input -> input.endsWith(".class")) ); Set<Class<? extends OpenCGAAnalysis>> plugins = reflections.getSubTypesOf(OpenCGAAnalysis.class); List<String> duplicatedPlugins = new LinkedList<>(); for (Class<? extends OpenCGAAnalysis> pluginClazz : plugins) { try { OpenCGAAnalysis plugin = pluginClazz.newInstance(); String pluginId = plugin.getIdentifier(); if (pluginsIdMap.containsKey(pluginId)) { logger.error("Duplicated ID for class {} and {}", pluginClazz, pluginsIdMap.get(pluginId)); duplicatedPlugins.add(pluginId); continue; } pluginsIdMap.put(pluginId, pluginClazz); } catch (InstantiationException | IllegalAccessException | RuntimeException e) { logger.error("Unable to load class {} ", pluginClazz); } } duplicatedPlugins.forEach(pluginsIdMap::remove); }
.filterInputsBy(filter) .setScanners(new ResourcesScanner()) .setUrls(ClasspathHelper.forJavaClassPath()));
urls.addAll(ClasspathHelper.forJavaClassPath()); urls.addAll(ClasspathHelper.forClassLoader()); for(int i = 0; i < packs.length; i++)
/** * @param m * @param predicate */ public EntityScanner(final Morphia m, com.google.common.base.Predicate<String> predicate) { if (predicate == null) { predicate = Predicates.alwaysTrue(); } Assert.parametersNotNull("m, predicate", m, predicate); final ConfigurationBuilder conf = new ConfigurationBuilder(); conf.setScanners(new TypesScanner(), new TypeAnnotationsScanner()); final Set<URL> s = new HashSet<URL>(); s.addAll(ClasspathHelper.forJavaClassPath()); s.addAll(Arrays.asList(ClasspathUrlFinder.findClassPaths())); conf.setUrls(new ArrayList(s)); conf.filterInputsBy(predicate); final Reflections r = new Reflections(conf); final Set<Class<?>> entities = r.getTypesAnnotatedWith(Entity.class); for (final Class<?> c : entities) { m.map(c); } } }
private void scanConceptsWithReflections() throws ObjectStoreConfigException { logger.debug("Search for concepts with reflections"); Set<URL> classpath = new HashSet<>(); classpath.addAll(ClasspathHelper.forClassLoader()); classpath.addAll(ClasspathHelper.forJavaClassPath()); classpath.addAll(ClasspathHelper.forManifest()); classpath.addAll(ClasspathHelper.forPackage("")); Reflections reflections = new Reflections(new ConfigurationBuilder() .setUrls(classpath) .useParallelExecutor() .filterInputsBy(FilterBuilder.parsePackages("-java, -javax, -sun, -com.sun")) .setScanners(new SubTypesScanner(), new TypeAnnotationsScanner())); Set<Class<?>> annotated = reflections.getTypesAnnotatedWith(Iri.class, true); logger.debug("Search for concepts with reflections resulted in " + annotated.size() + " classes"); for (Class clazz : annotated) { logger.debug("Found concept class: " + clazz.getCanonicalName()); roleMapper.addConcept(clazz); } }
private Collection<Field> collectAnnotatedFields() { final Reflections reflections = new Reflections(new ConfigurationBuilder().setUrls(ClasspathHelper.forJavaClassPath()) .setScanners(new FieldAnnotationsScanner())); return reflections.getFieldsAnnotatedWith(Register.class); }
public InjectorTranslator() throws NotFoundException { Reflections reflections = new Reflections(new ConfigurationBuilder() .setUrls(ClasspathHelper.forJavaClassPath()) .setScanners(new MethodAnnotationsScanner())); for ( Method m : reflections.getMethodsAnnotatedWith(SequenceDiagram.class)) { for (Class<?> c : m.getAnnotation(SequenceDiagram.class).value()) { injector.addDiagramClass(c); } } }
public static void forceUseOfDefaultCatalogWithJavaClassPath(ManagementContext manager) { // TODO duplication with BrooklynRestApiLauncher ? // don't use any catalog.xml which is set ((BrooklynProperties)manager.getConfig()).put(BrooklynServerConfig.BROOKLYN_CATALOG_URL, BrooklynRestApiLauncher.SCANNING_CATALOG_BOM_URL); // sets URLs for a surefire ((LocalManagementContext)manager).setBaseClassPathForScanning(ClasspathHelper.forJavaClassPath()); // this also works // ((LocalManagementContext)manager).setBaseClassPathForScanning(ClasspathHelper.forPackage("brooklyn")); // but this (near-default behaviour) does not // ((LocalManagementContext)manager).setBaseClassLoader(getClass().getClassLoader()); }
classpath.addAll(ClasspathHelper.forJavaClassPath()); classpath.addAll(ClasspathHelper.forManifest()); classpath.addAll(ClasspathHelper.forPackage(""));
/** * A lazy-loaded class scanner. * <p> * This scans the whole classpath for classes that extend agent, and builds factories for them. */ private void scanForAgents() { //ensure that we do not scan more than once - once is enough. if (hasScanned) { return; } Reflections reflections = new Reflections(new ConfigurationBuilder() .setUrls(ClasspathHelper.forJavaClassPath()) .setScanners(new MethodAnnotationsScanner(), new SubTypesScanner(), new TypeAnnotationsScanner()) .setExpandSuperTypes(false)); //find all subtypes of the agent class scanForConstructors(reflections); // find all annotated static methods scanForStaticMethods(reflections); //ensure we do not scan again hasScanned = true; }