protected GuiceApplication(String... basePackages) { final ConfigurationBuilder confBuilder = new ConfigurationBuilder(); final FilterBuilder filterBuilder = new FilterBuilder(); if (basePackages.length == 0) { basePackages = new String[] {}; } logger.info("op=create, auto_scan_packages={}", (Object[]) basePackages); for (String pkg : basePackages) { confBuilder.addUrls(ClasspathHelper.forPackage(pkg)); filterBuilder.include(FilterBuilder.prefix(pkg)); } confBuilder.filterInputsBy(filterBuilder) .setScanners(new SubTypesScanner(), new TypeAnnotationsScanner()); this.reflections = new Reflections(confBuilder); }
/** * Prepares the logger context. Locates the context and * sets the configuration file. * @return the logger context */ private ServletContextListener prepareAndgetContextListener() { try { if (StringUtils.isNotBlank(this.loggerContextPackageName)) { final Collection<URL> set = ClasspathHelper.forPackage(this.loggerContextPackageName); final Reflections reflections = new Reflections(new ConfigurationBuilder().addUrls(set).setScanners(new SubTypesScanner())); final Set<Class<? extends ServletContextListener>> subTypesOf = reflections.getSubTypesOf(ServletContextListener.class); final ServletContextListener loggingContext = subTypesOf.iterator().next().newInstance(); this.context.setInitParameter(this.logConfigurationField, this.logConfigurationFile.getURI().toString()); return loggingContext; } return null; } catch (final Exception e) { throw new RuntimeException(e); } }
/** * Gets cas banner instance. * * @return the cas banner instance */ public static Banner getCasBannerInstance() { final String packageName = CasEmbeddedContainerUtils.class.getPackage().getName(); final Reflections reflections = new Reflections(new ConfigurationBuilder() .filterInputsBy(new FilterBuilder().includePackage(packageName)) .setUrls(ClasspathHelper.forPackage(packageName)) .setScanners(new SubTypesScanner(true))); final Set<Class<? extends AbstractCasBanner>> subTypes = reflections.getSubTypesOf(AbstractCasBanner.class); subTypes.remove(DefaultCasBanner.class); if (subTypes.isEmpty()) { return new DefaultCasBanner(); } try { final Class<? extends AbstractCasBanner> clz = subTypes.iterator().next(); LOGGER.debug("Created banner [{}]", clz); return clz.newInstance(); } catch (final Exception e) { LOGGER.error(e.getMessage(), e); } return new DefaultCasBanner(); }
public ReflectionsServiceDiscovery(String resourceSearchPackages, JsonServiceLocator locator) { this.locator = locator; ConfigurationBuilder builder = new ConfigurationBuilder(); PreconditionUtil.assertNotNull("no resourceSearchPackage configured", resourceSearchPackages); FilterBuilder filter = new FilterBuilder(); for (String resourceSearchPackage : resourceSearchPackages.split(",")) { builder = builder.addUrls(ClasspathHelper.forPackage(resourceSearchPackage)); filter.includePackage(resourceSearchPackage); } filter.includePackage(Repository.class.getPackage().getName()); filter.includePackage(ResourceRepository.class.getPackage().getName()); builder = builder.filterInputsBy(filter); builder = builder.addUrls(ClasspathHelper.forClass(Repository.class)); builder = builder.addUrls(ClasspathHelper.forClass(ResourceRepository.class)); builder = builder.addUrls(ClasspathHelper.forClass(ResourceRepositoryV2.class)); builder = builder.setScanners(new SubTypesScanner(false), new TypeAnnotationsScanner()); reflections = new Reflections(builder); }
public CommandHandler() { try { Set<URL> classPathList = new HashSet<>(); classPathList.addAll(ClasspathHelper.forJavaClassPath()); Set<Class<? extends Command>> result = new Reflections( new ConfigurationBuilder().setScanners(new SubTypesScanner()).setUrls(classPathList)) .getSubTypesOf(Command.class); for (Class<? extends Command> c : result) { String[] categoryString = c.getPackage().toString().split("\\."); String category = categoryString[categoryString.length - 1]; if (category.equalsIgnoreCase("commands")) { category = "default"; } Command command = c.newInstance(); command.getSettings().setCategory(category); commands.add(command); } } catch (Exception e) { e.printStackTrace(); } }
private static <T> List<Class<? extends T>> concreteSubTypesOf(final Class<? extends T> clazz) { final ConfigurationBuilder conf = new ConfigurationBuilder() .setUrls(ClasspathHelper.forClass(clazz)) .setScanners(new SubTypesScanner(true)); final Reflections reflections = new Reflections(conf); final List<Class<? extends T>> result = new ArrayList<>(); for (final Class<? extends T> type : reflections.getSubTypesOf(clazz)) { if (type.isInterface()) { continue; } if (Modifier.isAbstract(type.getModifiers())) { continue; } result.add(type); } return result; }
@Override public List<TreeItem<Pair<AnnotatedElement, Object>>> query() { final List<TreeItem<Pair<AnnotatedElement, Object>>> results = new ArrayList<>(); final Predicate<String> childPredicate = Pattern.compile("^" + (pakkage != null ? "\\." + pakkage.getName() : "") + REGEX_CHILD_SUFFIX).asPredicate(); Arrays.asList(Package.getPackages()).stream().filter(p -> childPredicate.test(p.getName())).map(PackageTreeItem::new).forEach(results::add); if (pakkage != null) { final Reflections reflections = new Reflections(pakkage.getName(), new SubTypesScanner(false)); reflections.getStore().getSubTypesOf(Object.class.getName()).stream().map(s -> { try { return Class.forName(s); } catch (ClassNotFoundException e) { e.printStackTrace(); } return null; }).map(c -> ((QueriableTreeItem) new ReflectiveTreeItem.StaticReflectiveTreeItem(c))).filter(qti -> !qti.query().isEmpty()).forEach(results::add); } return results; }
private void doPackage(FilterBuilder fb, List<RuleFactory> resultL) throws Exception { List<ClassLoader> classLoadersList = new LinkedList<ClassLoader>(); classLoadersList.add(ClasspathHelper.contextClassLoader()); classLoadersList.add(ClasspathHelper.staticClassLoader()); Reflections reflections = new Reflections(new ConfigurationBuilder() .setScanners(new SubTypesScanner(false /* don't exclude Object.class */), new ResourcesScanner()) .setUrls(ClasspathHelper.forClassLoader(classLoadersList.toArray(new ClassLoader[0]))) .filterInputsBy(fb)); Set<Class<? extends RuleFactory>> subTypes = reflections.getSubTypesOf(RuleFactory.class); for(Class<? extends RuleFactory> clazz : subTypes) { RuleFactory factory = clazz.newInstance(); resultL.add(factory); } }
@Test public void testReflections() throws Exception { List<ClassLoader> classLoadersList = new LinkedList<ClassLoader>(); classLoadersList.add(ClasspathHelper.contextClassLoader()); classLoadersList.add(ClasspathHelper.staticClassLoader()); String packageName = "org.dnal.core.world"; Reflections reflections = new Reflections(new ConfigurationBuilder() .setScanners(new SubTypesScanner(false /* don't exclude Object.class */), new ResourcesScanner()) .setUrls(ClasspathHelper.forClassLoader(classLoadersList.toArray(new ClassLoader[0]))) .filterInputsBy(new FilterBuilder().include(FilterBuilder.prefix(packageName)))); Set<String> types = reflections.getAllTypes(); for(String s : types) { System.out.println(s); } Set<Class<? extends RuleFactory>> subTypes = reflections.getSubTypesOf(RuleFactory.class); for(Class<? extends RuleFactory> clazz : subTypes) { System.out.println("sub: " + clazz.getName()); RuleFactory factory = clazz.newInstance(); RuleDeclaration decl = factory.getDeclaration(); System.out.println("d: " + decl.ruleName); } }
public BeanScanner(final BeanManagerImpl beanManager, final ClassLoader classLoader, final String packageToScan) { this.beanManager = beanManager; final ConfigurationBuilder config = new ConfigurationBuilder(); config.setClassLoaders(new ClassLoader[] {classLoader}); config.setUrls(ClasspathHelper.forPackage(packageToScan, classLoader)); if (StringUtils.isNotEmpty(packageToScan)) { config.filterInputsBy(new FilterBuilder().includePackage(packageToScan)); } config.useParallelExecutor(); config.setScanners(new SubTypesScanner(false)); this.reflections = new Reflections(config); }
/** * Finds all package names starting with prefix * @param prefix The package in which to start searching * @param statik True to statically return components names * @return a set of component name */ public List<String> findAllPackagesStartingWith(final String prefix, final boolean statik) { final List<ClassLoader> classLoadersList = new ArrayList<>(); classLoadersList.add(ClasspathHelper.contextClassLoader()); Reflections reflections = new Reflections(new ConfigurationBuilder() .setScanners(new SubTypesScanner(false), new ResourcesScanner()) .setUrls(ClasspathHelper.forClassLoader(classLoadersList.toArray(new ClassLoader[classLoadersList.size()]))) .filterInputsBy(new FilterBuilder().include(FilterBuilder.prefix(prefix)))); Set<Class<?>> classes = reflections.getSubTypesOf(Object.class); final Set<String> packages = new HashSet<>(); for (final Class classInstance : classes) { String packageName = classInstance.getPackage().getName(); packageName = packageName.split("\\.")[packageName.split("\\.").length-1].toLowerCase(); packages.add(packageName); } return new ArrayList<>(packages); }
private static Collection<? extends Class<?>> getPackageTypes(String packageToPase, Collection<URL> urls) { Set<Class<?>> classes = new HashSet<>(); Reflections reflections = new Reflections(new ConfigurationBuilder() .setScanners(new SubTypesScanner(false /* exclude Object.class */), new ResourcesScanner(), new TypeElementsScanner()) .setUrls(urls) .filterInputsBy(new FilterBuilder().include(FilterBuilder.prefix(packageToPase)).exclude("java.*"))); Set<String> types; types = reflections.getStore().get("TypeElementsScanner").keySet(); for (String type: types) { Class<?> aClass = TypesHelper.loadClass(type, CLASS_LOADER); boolean wantedElement = StringUtils.startsWith(type, packageToPase); if (null != aClass && wantedElement) { logger.log(Level.INFO, "looking up for type: " + type); classes.add(aClass); } } return classes; }
public static void scanForCommands() { //Populate all the cmds System.out.println("[EvenWurse] Reloading cmd list..."); ArrayList<ClassLoader> classLoadersList = new ArrayList<>(); classLoadersList.add(ClasspathHelper.contextClassLoader()); classLoadersList.add(ClasspathHelper.staticClassLoader()); Reflections reflections = new Reflections( new ConfigurationBuilder().setScanners(new SubTypesScanner(), new ResourcesScanner()).setUrls( ClasspathHelper .forClassLoader(classLoadersList.toArray(new ClassLoader[classLoadersList.size()])))); Set<Class<? extends Cmd>> classes = reflections.getSubTypesOf(Cmd.class); KNOWN_CMDS = new Class[classes.size()]; for (int i = 0; i < classes.size(); i++) { KNOWN_CMDS[i] = (Class<? extends Cmd>) classes.toArray()[i]; System.out.println("[EvenWurse] Found cmd: " + KNOWN_CMDS[i].getSimpleName() + "!"); } System.out.println("[EvenWurse] Found " + KNOWN_CMDS.length + " cmds!"); }
public static void scanForMods() { //Populate all the mods System.out.println("[EvenWurse] Reloading mod list..."); ArrayList<ClassLoader> classLoadersList = new ArrayList<>(); classLoadersList.add(ClasspathHelper.contextClassLoader()); classLoadersList.add(ClasspathHelper.staticClassLoader()); Reflections reflections = new Reflections( new ConfigurationBuilder().setScanners(new SubTypesScanner(), new ResourcesScanner()).setUrls( ClasspathHelper .forClassLoader(classLoadersList.toArray(new ClassLoader[classLoadersList.size()])))); Set<Class<? extends Mod>> classes = reflections.getSubTypesOf(Mod.class); KNOWN_MODS = new Class[classes.size()]; for (int i = 0; i < classes.size(); i++) { KNOWN_MODS[i] = (Class<? extends Mod>) classes.toArray()[i]; System.out.println("[EvenWurse] Found mod: " + KNOWN_MODS[i].getSimpleName() + "!"); } System.out.println("[EvenWurse] Found " + KNOWN_MODS.length + " mods!"); }
public void addLoader(ClassLoader loader) { if (builder == null) { this.builder = new ConfigurationBuilder(); builder.setScanners(new SubTypesScanner(), new TypeAnnotationsScanner()); } builder.addClassLoader(loader); builder.addUrls(ClasspathHelper.forClassLoader(loader)); if(loader instanceof JoinClassLoader) { // When the object "reflections" is created in the method scanClassPath(), are scanned the URLs so // it is necessary to add the URLs from the enclosing class loader in the JoinClassLoader that it // contains the fixture classpath (see org.reflections.Reflections.scan()). builder.addUrls(ClasspathHelper.forClassLoader(((JoinClassLoader) loader).getEnclosingClassLoader())); } scanClassPath(builder); }
public synchronized void init(ServletContext context) { if (HANDLERS != null) { return; } LOG.info("Initializing output handlers..."); Map<String, Class<? extends IOutputHandler>> handlers = new HashMap<>(); Reflections reflections = new Reflections(new ConfigurationBuilder() .addUrls(ClasspathHelper.forWebInfLib(context)) .setScanners(new TypeAnnotationsScanner(), new SubTypesScanner(false))); Set<Class<?>> classes = reflections.getTypesAnnotatedWith(OutputHandler.class); for (Class<?> clazz : classes) { LOG.info("Found annotated output handler class: " + clazz.getName()); if (IOutputHandler.class.isAssignableFrom(clazz)) { String id = clazz.getAnnotation(OutputHandler.class).id(); //noinspection unchecked handlers.put(id, (Class<? extends IOutputHandler>)clazz); LOG.info("Added output handler " + id + " in class: " + clazz.getName()); } } HANDLERS = handlers; LOG.info("Initialization of output handlers completed."); }
public void test() { final Reflections reflections = new Reflections(new ConfigurationBuilder() .addUrls(ClasspathHelper.forClassLoader()) .setScanners(new TypeAnnotationsScanner(), new SubTypesScanner()) ); final Set<Class<?>> classes_withValidator = reflections.getTypesAnnotatedWith(Validator.class); System.out.println("Found " + classes_withValidator.size() + " classes annotated with " + Validator.class); final Set<Class<?>> classes_withInterceptor = reflections.getTypesAnnotatedWith(Interceptor.class); System.out.println("Found " + classes_withInterceptor.size() + " classes annotated with " + Interceptor.class); final Set<Class<?>> classes = ImmutableSet.<Class<?>> builder() .addAll(classes_withValidator) .addAll(classes_withInterceptor) .build(); System.out.println("=> " + classes.size() + " classes to test"); for (final Class<?> clazz : classes) { testClass(clazz); } assertNoExceptions(); }
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); } }
/** * Init stuff is responsible to grab all DTOs found in classpath (classloader) and setup model for * String Template */ protected void init() { ConfigurationBuilder configurationBuilder = new ConfigurationBuilder().setScanners(new SubTypesScanner(), new TypeAnnotationsScanner()); if (useClassPath) { configurationBuilder.setUrls(forJavaClassPath()); } else { configurationBuilder.setUrls(forClassLoader()); } // keep only DTO interfaces Reflections reflections = new Reflections(configurationBuilder); List<Class<?>> annotatedWithDtos = new ArrayList<>(reflections.getTypesAnnotatedWith(DTO.class)); List<Class<?>> interfacesDtos = annotatedWithDtos .stream() .filter(clazz -> clazz.isInterface()) .collect(Collectors.toList()); interfacesDtos.stream().forEach(this::analyze); }
@Override public void execute() throws MojoExecutionException, MojoFailureException { Reflections reflections = new Reflections(new ConfigurationBuilder() .setUrls(ClasspathHelper.forPackage(basePackage)).setScanners( new SubTypesScanner(), new TypeAnnotationsScanner())); Set<Class<?>> resources = reflections .getTypesAnnotatedWith(Resource.class); Set<Class<?>> apis = reflections .getTypesAnnotatedWith(ApiGateway.class); Map<String, EndpointResource> endpointResources = getEndpointResources(resources); String apiName = getApiName(apis); fileWriter.createSwaggerFile(new ArrayList<EndpointResource>(endpointResources.values()), apiName); }
@SuppressWarnings("unchecked") private void registerScriptEngineFactories() { List<ClassLoader> classLoadersList = new LinkedList<ClassLoader>(); classLoadersList.add(ClasspathHelper.contextClassLoader()); classLoadersList.add(ClasspathHelper.staticClassLoader()); Reflections reflections = new Reflections(new ConfigurationBuilder() .setScanners(new SubTypesScanner(), new TypeAnnotationsScanner(), new ResourcesScanner()) .setUrls(ClasspathHelper.forClassLoader(classLoadersList.toArray(new ClassLoader[0]))) .filterInputsBy(new FilterBuilder().include(FilterBuilder.prefix("com.jsen")))); Set<Class<?>> annotated = reflections.getTypesAnnotatedWith(ScriptEngineFactory.class); for (Class<?> clazz : annotated) { if (AbstractScriptEngineFactory.class.isAssignableFrom(clazz)) { registerMimeContentFactory((Class<AbstractScriptEngineFactory>)clazz); } } }
public ModelInfoLookup(ModelNamingStrategy namingStrategy, String packageName, ClassLoader classLoader) { this.packageName = packageName; this.namingStrategy = namingStrategy; this.classLoader = classLoader; Reflections reflections = new Reflections(packageName, new SubTypesScanner(false)); Set<String> typeNames = reflections.getAllTypes(); System.out.println("type names size: " + typeNames.size()); typeNames.forEach(typeName -> { try { addClass(classLoader.loadClass(typeName)); } catch (ClassNotFoundException e) { logger.error("error loading model info lookup", e); } }); addSuperAndSubclassInfo(); inConstructor = false; }
private Set<Class<?>> getSubtypes(final Class<?> type) throws ComboBoxIsTooFullException { final ClassLoader[] classloaders = new ClassLoader[] { currentModelHandler.getCustomClassLoader(), currentModelHandler.getCustomClassLoader().getParent() }; final ConfigurationBuilder builder = new ConfigurationBuilder(). addUrls(ClasspathHelper.forClassLoader(currentModelHandler.getCustomClassLoader())). addClassLoaders(classloaders). setScanners(new SubTypesScanner(false)); final Reflections ref = new Reflections(builder); final Set<Class<?>> result = new HashSet<Class<?>>(); final Set<String> subTypesStr = ref.getStore().getSubTypesOf(type.getName()); if (subTypesStr.size() > MAX_SIZE_OF_SUBPARAMETER_COMBOBOX) throw new ComboBoxIsTooFullException(); for (final String clsName : subTypesStr) { try { result.add(ReflectionUtils.forName(clsName,classloaders)); } catch (final ReflectionsException e) { // intentionally blank } } return result; }
/** * Creates a {@link org.reflections.Reflections} with the given packages (configuration) * * @param scanPackages */ private void createReflections(String[] scanPackages) { if (scanPackages.length < 1) { LOGGER.warn("No package defined in configuration (scanPackages)!"); return; } ConfigurationBuilder configurationBuilder = new ConfigurationBuilder(); FilterBuilder filterBuilder = new FilterBuilder(); for (String packageName : scanPackages) { configurationBuilder.addUrls(ClasspathHelper.forPackage(packageName)); filterBuilder.include(FilterBuilder.prefix(packageName)); } configurationBuilder.filterInputsBy(filterBuilder).setScanners(new SubTypesScanner(), new TypeAnnotationsScanner()); this.reflections = new Reflections(configurationBuilder); }
/** * creates a sortedset of all hook implementations found for the given hook. Ordering is done through * {@link com.github.cherimojava.orchidae.hook.HookHandler.HookComparator} in reverse order * * @param hook to find all implementations from * @param url where to search for hook implementations * @param <H> Hook type * @return sortedset with all found hook implementation */ public static <H> SortedSet<? extends H> getHookOrdering( Class<H> hook, URL url ) { Configuration config = new ConfigurationBuilder().addUrls( url ) .addUrls( ClasspathHelper.forPackage( HookHandler.class.getPackage().getName() ) ) .setScanners( new SubTypesScanner() ); Reflections reflect = new Reflections( config ); SortedSet<H> hooks = Sets.newTreeSet( new ReverseComparator( comparator ) ); LOG.info( "Searching for hooks of {}", hook ); for ( Class<? extends H> c : reflect.getSubTypesOf( hook ) ) { try { LOG.info( "Found hook {}", c ); hooks.add( c.newInstance() ); } catch ( IllegalAccessException | InstantiationException e ) { LOG.error( "Failed to instantiate {} please make sure it has a no param Constructor. {}", c, e ); } } return hooks; }
/** * Creates reflection for package and base class. * @param pack * @param clazz */ public Reflection(String pack, Class clazz) { if (clazz.equals(Object.class)) { // @see http://stackoverflow.com/a/9571146 List<ClassLoader> classLoadersList = new LinkedList(); classLoadersList.add(ClasspathHelper.contextClassLoader()); classLoadersList.add(ClasspathHelper.staticClassLoader()); this.reflections = new Reflections(new ConfigurationBuilder() .setScanners(new SubTypesScanner(false), new ResourcesScanner()) .addUrls(ClasspathHelper.forClassLoader(classLoadersList.toArray(new ClassLoader[0]))) .addUrls(ClasspathHelper.forClassLoader(classLoadersList.toArray(new ClassLoader[1]))) .addUrls(ClasspathHelper.forJavaClassPath()) .filterInputsBy(new FilterBuilder().include(FilterBuilder.prefix(pack)))); } else { this.reflections = new Reflections(clazz); } }
private void init() { providers = Maps.newConcurrentMap(); // use reflection to load providers final Set<Class<? extends IRealizationProvider>> realizationProviders = new Reflections("org.apache.kylin", new SubTypesScanner()).getSubTypesOf(IRealizationProvider.class); List<Throwable> es = Lists.newArrayList(); for (Class<? extends IRealizationProvider> cls : realizationProviders) { try { IRealizationProvider p = (IRealizationProvider) cls.getMethod("getInstance", KylinConfig.class).invoke(null, config); providers.put(p.getRealizationType(), p); } catch (Exception | NoClassDefFoundError e) { es.add(e); } if (es.size() > 0) { for (Throwable exceptionOrError : es) { logger.error("Create new store instance failed ", exceptionOrError); } throw new IllegalArgumentException("Failed to find metadata store by url: " + config.getMetadataUrl()); } } logger.info("RealizationRegistry is " + providers); }
private Reflections buildReflections(String packages) { String[] packagesArray = packages.replaceAll(" ", "").split(","); FilterBuilder filter = new FilterBuilder(); Set<URL> urls = new HashSet(); for (String packageStr : packagesArray) { urls.addAll(ClasspathHelper.forPackage(packageStr)); filter.include(FilterBuilder.prefix(packageStr)); } return new Reflections(new ConfigurationBuilder() .addUrls(urls) .filterInputsBy(filter) .setScanners(new TypeAnnotationsScanner(), new SubTypesScanner())); }
@Test public void testAll() throws IOException { List<ClassLoader> classLoadersList = ImmutableList.of( ClasspathHelper.contextClassLoader(), ClasspathHelper.staticClassLoader() ); Reflections reflections = new Reflections(new ConfigurationBuilder() .setScanners(new SubTypesScanner(false /* don't exclude Object.class */)) .setUrls(ClasspathHelper.forClassLoader(classLoadersList.toArray(new ClassLoader[0]))) .filterInputsBy(new FilterBuilder().include(FilterBuilder.prefix("net.bramp.dissector"))) ); for (Class clazz : reflections.getSubTypesOf(Object.class)) { System.out.print(clazz); String c = clazz.getName(); c = c.substring(c.lastIndexOf('.') + 1); // There might be a better way than this! ExtendedRandomAccessFile in = open( clazz, c + ".class" ); new PngDissector().read(in); // Read but don't do anything with it System.out.println(" [OK]"); } }
private Set<String> findAllPackages() { final List<ClassLoader> classLoadersList = new LinkedList<ClassLoader>(); classLoadersList.add(ClasspathHelper.contextClassLoader()); classLoadersList.add(ClasspathHelper.staticClassLoader()); final Reflections reflections = new Reflections(new ConfigurationBuilder() .setScanners(new SubTypesScanner(false), new ResourcesScanner()) .setUrls(ClasspathHelper.forClassLoader(classLoadersList.toArray(new ClassLoader[classLoadersList.size()]))) .filterInputsBy(new FilterBuilder().include(FilterBuilder.prefix(basePackage)))); final Set<Class<?>> classes = reflections.getSubTypesOf(Object.class); final Set<String> packageNameSet = new TreeSet<String>(); for (final Class classInstance : classes) { packageNameSet.add(classInstance.getPackage().getName()); } return packageNameSet; }
private static void RegisterActors(Binder binder) { Logger.debug("Actor Scanner Started..."); final Map<String, ActorHolder> map = new HashMap<>(); final ConfigurationBuilder configBuilder = build(); final Reflections reflections = new Reflections(configBuilder.setScanners(new SubTypesScanner())); final Set<Class<? extends UntypedActor>> actors = reflections.getSubTypesOf(UntypedActor.class); final Set<Class<? extends AbstractActor>> abstractActors = reflections.getSubTypesOf(AbstractActor.class); loopOnActors(map, actors); loopOnAbstractActors(map, abstractActors); if(!map.isEmpty()) Logger.debug("Registering actors: "); for(final String key : map.keySet()) { final ActorHolder actorHolder = map.get(key); final Class<? extends Actor> actor = actorHolder.getActor(); if(actorHolder.isSingleton()) { Logger.debug("Binding class " + actor.getSimpleName() + " to name: " + key + " Singleton Scoped."); binder.bind(ActorRef.class).annotatedWith(Names.named(key)).toProvider(new ActorRefProvider(actor, key, true)).in(Singleton.class); } else { Logger.debug("Binding class " + actor.getSimpleName() + " to name: " + key + " Request Scoped."); binder.bind(ActorRef.class).annotatedWith(Names.named(key)).toProvider(new ActorRefProvider(actor, key, false)); PropsContext.put(key, actorHolder); } } }
protected void loadCompressors() { /* We scan classpath for NDArrayCompressor implementations and add them one by one to codecs map */ codecs = new ConcurrentHashMap<>(); Set<Class<? extends NDArrayCompressor>> classes = 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 .setUrls(ClasspathHelper.forPackage("org.nd4j")).setScanners(new SubTypesScanner())) .getSubTypesOf(NDArrayCompressor.class); for (Class<? extends NDArrayCompressor> impl : classes) { if (Modifier.isAbstract(impl.getModifiers()) || impl.isInterface()) continue; try { NDArrayCompressor compressor = impl.newInstance(); codecs.put(compressor.getDescriptor().toUpperCase(), compressor); } catch (InstantiationException i) { ; // we need catch there, to avoid exceptions at abstract classes } catch (Exception e) { throw new RuntimeException(e); } } }
private void addSupportedOperations(String[] opPackages) { Set<URL> packages = new HashSet<>(); for (String opPackage : opPackages) { packages.addAll(ClasspathHelper.forPackage(opPackage)); } Reflections reflections = new Reflections(packages, new SubTypesScanner()); for (Class<? extends Operation> opClass : reflections.getSubTypesOf(Operation.class)) { if (Modifier.isAbstract(opClass.getModifiers())) continue; DisplayName displayName = opClass.getAnnotation(DisplayName.class); if (displayName != null ) { operations.put(displayName.value(), opClass); }else{ throw new RuntimeException(opClass.getSimpleName() + " is an invalid Operation."); } } }
private void init(String packageName) { FilterBuilder filters = new FilterBuilder().includePackage(packageName); Scanner[] scanners = { new TypeAnnotationsScanner(), new MethodAnnotationsScanner(), new MethodParameterScanner(), new FieldAnnotationsScanner(), new SubTypesScanner().filterResultsBy(filters) }; reflections = new ConfigurationBuilder() .addUrls(ClasspathHelper.forPackage(packageName)) .addScanners(scanners) .filterInputsBy(filters) .build(); }
/** * https://github.com/ronmamo/reflections/issues/81 */ @Test public void reflections_scan_is_thread_safe() throws Exception { Callable<Set<Class<? extends ImmutableMap>>> callable = new Callable<Set<Class<? extends ImmutableMap>>>() { @Override public Set<Class<? extends ImmutableMap>> call() throws Exception { final Reflections reflections = new Reflections(new ConfigurationBuilder() .setUrls(singletonList(ClasspathHelper.forClass(ImmutableMap.class))) .setScanners(new SubTypesScanner(false))); return reflections.getSubTypesOf(ImmutableMap.class); } }; final ExecutorService pool = Executors.newFixedThreadPool(2); final Future<?> first = pool.submit(callable); final Future<?> second = pool.submit(callable); assertEquals(first.get(5, SECONDS), second.get(5, SECONDS)); }
public static ArrayList<Class> getSubtypes(String rootPackage) { log.debug("------------ Getting all children of MOI from package: " + rootPackage); Reflections reflections = new Reflections(new ConfigurationBuilder() .filterInputsBy(new FilterBuilder.Include(FilterBuilder.prefix(rootPackage))) .setUrls(ClasspathHelper.forPackage(rootPackage)) .setScanners(new SubTypesScanner(), new TypeAnnotationsScanner(), new ResourcesScanner())); ArrayList<Class> annoList = new ArrayList<Class>(); annoList.addAll(reflections.getTypesAnnotatedWith(IgnoreFromTableCreation.class, true)); log.debug("annoList.size()::" + annoList.size()); ArrayList<Class> subTypesList = new ArrayList<Class>(); subTypesList.addAll(reflections.getSubTypesOf(ModelObjectInterface.class)); log.debug("getSubtypes: removing because it's annotated with @IgnoreFromTableCreation clazz = " + annoList); subTypesList.removeAll(annoList); log.debug("getSubtypes: found types: " + subTypesList); return subTypesList; }
public static ArrayList<Class> getSubtypes(Class rootClass) { log.debug("------------ Getting all children of MOI for class: " + rootClass.getCanonicalName()); Reflections reflections = new Reflections(new ConfigurationBuilder() .setUrls(ClasspathHelper.forClass(rootClass)) .setScanners(new SubTypesScanner(), new TypeAnnotationsScanner(), new ResourcesScanner())); ArrayList<Class> annoList = new ArrayList<Class>(); annoList.addAll(reflections.getTypesAnnotatedWith(IgnoreFromTableCreation.class, true)); log.debug("annoList.size()::" + annoList.size()); ArrayList<Class> subTypesList = new ArrayList<Class>(); subTypesList.addAll(reflections.getSubTypesOf(ModelObjectInterface.class)); log.debug("getSubtypes: removing because it's annotated with @IgnoreFromTableCreation clazz = " + annoList); subTypesList.removeAll(annoList); log.debug("getSubtypes: found types: " + subTypesList); return subTypesList; }
@Path("virtualips") public Object retrieveVirtualIpsResource() throws IllegalAccessException, InstantiationException { String enabledExtension = PluginConfiguration.getExtensionPrefix(); ConfigurationBuilder configBuilder = new ConfigurationBuilder(); configBuilder.addUrls(ClasspathHelper.forPackage("org.daylight.pathweaver." + enabledExtension + ".api")); // TODO: Decompose this out and dynamically resolve sub-resource base off of extensions prefix Reflections reflections = new Reflections(configBuilder.setScanners(new SubTypesScanner())); Set<Class<? extends VirtualIpsResource>> subTypes = reflections.getSubTypesOf(VirtualIpsResource.class); if (subTypes.iterator().hasNext()) { final Class<? extends VirtualIpsResource> subClass = subTypes.iterator().next(); final VirtualIpsResource bean = PluginContextLoaderListener.getCurrentWebApplicationContext().getBean(subClass); bean.setLoadBalancerId(id); bean.setAccountId(accountId); return bean; } else { virtualIpsResource.setLoadBalancerId(id); virtualIpsResource.setAccountId(accountId); return virtualIpsResource; } }