Java 类org.reflections.util.FilterBuilder 实例源码

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);
}

/**
 * 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);
}

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);
    }

}

private ArrayList<String> getResourceDirectoryContent(String resourcePattern) {
    ArrayList<String> tempFilesContentList = new ArrayList<>();

    Reflections reflections = new Reflections(new ConfigurationBuilder()
                                                    .setUrls(ClasspathHelper.forPackage("io.logz"))
                                                    .setScanners(new ResourcesScanner())
                                                    .filterInputsBy(new FilterBuilder().include(resourcePattern)));
    Set<String> properties = reflections.getResources(Pattern.compile(".*\\.json"));

    properties.forEach((resourceName) -> {

        URL resourceUrl = Resources.getResource(resourceName);
        try {
            tempFilesContentList.add(Resources.toString(resourceUrl, Charset.forName("utf-8")).replace("\n", ""));

        } catch (IOException e) {
            logger.info("Could not read file {}", resourceUrl.toString());
        }
    });

    if (tempFilesContentList.isEmpty())
        throw new RuntimeException("Did not find any files under "+ resourcePattern +"!");

    return tempFilesContentList;
}

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);
}

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);
}

/**
 * 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;
}

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);
    }
}

@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);  
        }
    }
}

/**
 * Scans the specified packages for annotated classes, and applies Config values to them.
 * 
 * @param config the Config to derive values from
 * @param packageNamePrefix the prefix to limit scanning to - e.g. "com.github"
 * @return The constructed TypesafeConfigModule.
 */
public static TypesafeConfigModule fromConfigWithPackage(Config config, String packageNamePrefix) {
     ConfigurationBuilder configBuilder = 
         new ConfigurationBuilder()
         .filterInputsBy(new FilterBuilder().includePackage(packageNamePrefix))
         .setUrls(ClasspathHelper.forPackage(packageNamePrefix))
         .setScanners(
            new TypeAnnotationsScanner(), 
            new MethodParameterScanner(), 
            new MethodAnnotationsScanner(), 
            new FieldAnnotationsScanner()
         );
    Reflections reflections = new Reflections(configBuilder);

    return new TypesafeConfigModule(config, reflections);
}

private Map<String, String> getAllDocStrings0(ClassLoader classLoader) {
    final Configuration configuration = new ConfigurationBuilder()
            .filterInputsBy(new FilterBuilder().includePackage(path))
            .setUrls(ClasspathHelper.forPackage(path))
            .addClassLoader(classLoader)
            .setScanners(new ResourcesScanner());
    if (configuration.getUrls() == null || configuration.getUrls().isEmpty()) {
        return Collections.emptyMap();
    }
    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);
}

public static List<URL> urls( String atPackage, String ext ) {
    final ExecutorService executorService = Executors.newFixedThreadPool(
        Runtime.getRuntime().availableProcessors(),
        new ThreadFactoryBuilder().setNameFormat( "reflections-%d" ).build()
    );
    try {
        final ConfigurationBuilder configuration = new ConfigurationBuilder()
            .setUrls( ClasspathHelper.forPackage( atPackage ) )
            .setScanners( new ResourcesScanner() )
            .filterInputsBy( new FilterBuilder().includePackage( atPackage ) )
            .setExecutorService( executorService );
        final Reflections reflections = new Reflections( configuration );

        final Set<String> resources = reflections.getResources( in -> in.endsWith( "." + ext ) );
        return new ArrayList<>( Sets.map( resources, r -> Thread.currentThread().getContextClassLoader().getResource( r ) ) );
    } finally {
        executorService.shutdown();
    }
}

/**
 * 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 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 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;
}

public static ApiDocumentation scan(String version, String path, List<String> packages) {

        Set<URL> urls = new HashSet<URL>();
        FilterBuilder filter = new FilterBuilder();

        log.debug("Scanning {} package(s)...", packages.size());
        for(String pkg : packages) {
            urls.addAll(ClasspathHelper.forPackage(pkg));
            filter.includePackage(pkg);
        }

        Reflections reflections = new Reflections(new ConfigurationBuilder()
                .filterInputsBy(filter).setUrls(urls));

        ApiDocumentation apiDoc = new ApiDocumentation(version, path);
        apiDoc.setRepositories(scanApiRepository(reflections.getTypesAnnotatedWith
                (ApiRepository.class)));
        apiDoc.setModels(scanApiModel(reflections.getTypesAnnotatedWith
                (ApiModel.class)));
        return apiDoc;
    }

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 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();
}

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;
}

/**
 * load every properties contained in the classpath
 * @return properties Object containing all loaded properties from every properties files contained in the classpath
 * @throws IOException
 */
public static Properties getProperties() throws IOException{
    Predicate<String> filter = new FilterBuilder().include(".*.properties");

    Reflections reflections = new Reflections(new ConfigurationBuilder()
            .filterInputsBy(filter)
            .setScanners(new ResourcesScanner())
            .setUrls(Arrays.asList(ClasspathHelper.forClass(PropertyLoader.class))));
    Set<String> propertiesfiles = reflections.getStore().get(ResourcesScanner.class).keySet();
    Properties prop = new Properties();
    for(Iterator<String> propertiesFilesIterator =  propertiesfiles.iterator(); propertiesFilesIterator.hasNext();){
        String currentPropertyFile = propertiesFilesIterator.next();
        InputStream is = PropertyLoader.class.getClassLoader().getResourceAsStream(currentPropertyFile);
        if(is != null){
            prop.load(is);
        }
    }
    return prop;
}

private Reflections initializeReflections(final String packageNameOfVictims,
                                          final List<ClassLoader> classLoadersList) {

  SubTypesScanner scanner = new SubTypesScanner(false);
  ClassLoader[] loaders = classLoadersList.toArray(new ClassLoader[0]);
  FilterBuilder filter = new FilterBuilder() {{
    include(FilterBuilder.prefix(packageNameOfVictims));
  }};

  ConfigurationBuilder builder = new ConfigurationBuilder()
      .setScanners(scanner, new ResourcesScanner())
      .setUrls(ClasspathHelper.forClassLoader(loaders))
      .filterInputsBy(filter);

  return new Reflections(builder);
}

public static <T extends NamedTest> List<T> loadJsonResourceFiles(String packageName, Class<T> cls) throws IOException {
//    Preconditions.checkNotNull(packageName, "packageName cannot be null");
    Reflections reflections = new Reflections(packageName, new ResourcesScanner());
    Set<String> resources = reflections.getResources(new FilterBuilder.Include(".*"));
    List<T> datas = new ArrayList<>(resources.size());
    Path packagePath = Paths.get("/" + packageName.replace(".", "/"));
    for (String resource : resources) {
      log.trace("Loading resource {}", resource);
      Path resourcePath = Paths.get("/" + resource);
      Path relativePath = packagePath.relativize(resourcePath);
      File resourceFile = new File("/" + resource);
      T data;
      try (InputStream inputStream = cls.getResourceAsStream(resourceFile.getAbsolutePath())) {
        data = ObjectMapperFactory.INSTANCE.readValue(inputStream, cls);
      } catch (IOException ex) {
        if (log.isErrorEnabled()) {
          log.error("Exception thrown while loading {}", resourcePath, ex);
        }
        throw ex;
      }
      String nameWithoutExtension = Files.getNameWithoutExtension(resource);
      if (null != relativePath.getParent()) {
        String parentName = relativePath.getParent().getFileName().toString();
        data.testName(parentName + "/" + nameWithoutExtension);
      } else {
        data.testName(nameWithoutExtension);
      }
      datas.add(data);
    }
    return datas;
  }

public OidcProfileScopeToAttributesFilter(final PrincipalFactory principalFactory,
                                          final ServicesManager servicesManager,
                                          final Collection<BaseOidcScopeAttributeReleasePolicy> userScopes,
                                          final OidcAttributeToScopeClaimMapper attributeToScopeClaimMapper) {
    this.attributeToScopeClaimMapper = attributeToScopeClaimMapper;
    this.filters = new HashMap<>();

    final String packageName = BaseOidcScopeAttributeReleasePolicy.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 BaseOidcScopeAttributeReleasePolicy>> subTypes =
            reflections.getSubTypesOf(BaseOidcScopeAttributeReleasePolicy.class);
    subTypes.forEach(Unchecked.consumer(t -> {
        final BaseOidcScopeAttributeReleasePolicy ex = t.newInstance();
        filters.put(ex.getScopeName(), ex);
    }));

    userScopes.forEach(t -> filters.put(t.getScopeName(), t));

    this.principalFactory = principalFactory;
    this.servicesManager = servicesManager;
    this.userScopes = userScopes;
}

public void generateReport(String packageName,List<String> flagList) throws IOException
{

    URL testClassesURL = Paths.get("target/test-classes").toUri().toURL();

    URLClassLoader classLoader = URLClassLoader.newInstance(new URL[]{testClassesURL},
            ClasspathHelper.staticClassLoader());

    reflections = new Reflections(new ConfigurationBuilder()
            .setUrls(ClasspathHelper.forPackage(packageName,classLoader))
            .addClassLoader(classLoader)
            .filterInputsBy(new FilterBuilder().includePackage(packageName))
            .setScanners(new MethodAnnotationsScanner(), new TypeAnnotationsScanner(), new SubTypesScanner())
    );


    List<Map<String, TestClass>> list = new ArrayList<>();

    for (String flag : flagList)
    {
        list.add(printMethods(flag));
    }

    Gson gson = new Gson();
    String overviewTemplate = IOUtils.toString(getClass().getResourceAsStream("/index.tpl.html"));


    String editedTemplate = overviewTemplate.replace("##TEST_DATA##", gson.toJson(list));

    FileUtils.writeStringToFile(new File("target/test-list-html-report/index.html"), editedTemplate);
    logger.info("report file generated");
}

public static Reflections getReflections(Class<?> appClass) {

        String packageName = appClass.getPackage().getName();

        return new Reflections(
                packageName,
                new SubTypesScanner(),
                new TypeAnnotationsScanner(),
                new FilterBuilder.Exclude(".*.xml")
        );
    }

static Set<Class<?>> getClasses(String packageName) {
    List<ClassLoader> classLoadersList = new LinkedList<>();
    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(new FilterBuilder().include(FilterBuilder.prefix(packageName))));

    Set<Class<?>> classes = reflections.getSubTypesOf(Object.class);
    return classes;
}

public Set<Class<?>> loadClasses() {
  Reflections reflections =
          new Reflections(
                  new ConfigurationBuilder()
                          .setUrls(ClasspathHelper.forPackage(packageToScan))
                          .setScanners(new SubTypesScanner(false), new TypeAnnotationsScanner())
                          .filterInputsBy(new FilterBuilder().includePackage(packageToScan)));

  Set<Class<?>> result = new LinkedHashSet<>();
  result.addAll(getClasses(reflections));
  return result;
}

private static void printUsage() {

        System.out.println("Usage: ./gradlew run -Pdemo=<demo>\n\nAvailable options for <demo>");

        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(new FilterBuilder().include(FilterBuilder.prefix(testsPackage))));

        Set<Class<?>> classes = reflections.getSubTypesOf(Object.class);
        TreeSet<String> sortedClasses = new TreeSet<String>();
        HashMap<String,String> classDescriptions = new HashMap<String, String>();
        for (Class<? extends Object> cl : classes) {
            if (!cl.getSimpleName().equals("")) {
                sortedClasses.add(cl.getSimpleName());
                String descString = "";
                if (cl.getAnnotation(DemoDescription.class) != null) descString = cl.getAnnotation(DemoDescription.class).desc();
                classDescriptions.put(cl.getSimpleName(),descString);
            }
        }
        for (String className : sortedClasses) {
            System.out.println();               
            List<String> descStrings = StringUtils.description("   \u001B[1m\u001b[32m"+className+"\u001b[0m: ", classDescriptions.get(className), 72, 6);
            for (String ds : descStrings) System.out.println(ds);
        }

        System.out.println();
        String note = "Most examples require the ReedsSheppCarPlanner motion planner, which is provided via a"
                + "linked library that has to be built and depends on ompl (http://ompl.kavrakilab.org/)"
                + "and mrpt (http://www.mrpt.org/). See REAME.md for building instructions.";
        List<String> formattedNote = StringUtils.description("NOTE: ", note, 72);
        for (String line : formattedNote) System.out.println(line);

    }

public static <T extends NamedTest> List<T> loadJsonResourceFiles(String packageName, Class<T> cls) throws IOException {
  Preconditions.checkNotNull(packageName, "packageName cannot be null");
  Reflections reflections = new Reflections(packageName, new ResourcesScanner());
  Set<String> resources = reflections.getResources(new FilterBuilder.Include(".*"));
  List<T> datas = new ArrayList<>(resources.size());
  Path packagePath = Paths.get("/" + packageName.replace(".", "/"));
  for (String resource : resources) {
    log.trace("Loading resource {}", resource);
    Path resourcePath = Paths.get("/" + resource);
    Path relativePath = packagePath.relativize(resourcePath);
    File resourceFile = new File("/" + resource);
    T data;
    try (InputStream inputStream = cls.getResourceAsStream(resourceFile.getAbsolutePath())) {
      data = ObjectMapperFactory.INSTANCE.readValue(inputStream, cls);
    } catch (IOException ex) {
      if (log.isErrorEnabled()) {
        log.error("Exception thrown while loading {}", resourcePath, ex);
      }
      throw ex;
    }
    String nameWithoutExtension = Files.getNameWithoutExtension(resource);
    if (null != relativePath.getParent()) {
      String parentName = relativePath.getParent().getFileName().toString();
      data.testName(parentName + "/" + nameWithoutExtension);
    } else {
      data.testName(nameWithoutExtension);
    }
    datas.add(data);
  }
  return datas;
}

public static Collection<Method> listAvailableMainMethods(String package_prefix, String exclude_regex) {

        ClassLoader[] classLoaders = new ClassLoader[] {
                // ReflectionUtilsTest.class.getClassLoader(),
                ClasspathHelper.contextClassLoader(),
                ClasspathHelper.staticClassLoader()
        };

        FilterBuilder filter = new FilterBuilder().include(package_prefix + ".*");
        if (exclude_regex != null)
            filter.exclude(exclude_regex).exclude("org\\.reflections.*");

        Reflections reflections = new Reflections(
                new ConfigurationBuilder()
                .setScanners(new SubTypesScanner(false /* don't exclude Object.class */))
                .setUrls(ClasspathHelper.forClassLoader(classLoaders))
                .filterInputsBy(filter));

        Set<Class<? extends Object>> types = reflections.getSubTypesOf(Object.class);

        Set<Method> main_methods = new HashSet<Method>();
        for (Class<? extends Object> clazz : types) {
            for (Method method : clazz.getMethods()) {
                if (isMainMethod(method))
                    main_methods.add(method);
            }
        }

        return main_methods;
    }

public static <T extends NamedTest> List<T> loadJsonResourceFiles(String packageName, Class<T> cls) throws IOException {
    Preconditions.checkNotNull(packageName, "packageName cannot be null");
    log.info("packageName = {}", packageName);
//    Preconditions.checkState(packageName.startsWith("/"), "packageName must start with a /.");
    Reflections reflections = new Reflections(packageName, new ResourcesScanner());
    Set<String> resources = reflections.getResources(new FilterBuilder.Include("^.*\\.json$"));
    List<T> datas = new ArrayList<T>(resources.size());
    Path packagePath = Paths.get("/" + packageName.replace(".", "/"));
    for (String resource : resources) {
      log.trace("Loading resource {}", resource);
      Path resourcePath = Paths.get("/" + resource);
      Path relativePath = packagePath.relativize(resourcePath);
      File resourceFile = new File("/" + resource);
      T data;
      try (InputStream inputStream = cls.getResourceAsStream(resourceFile.getAbsolutePath())) {
        data = ObjectMapperFactory.INSTANCE.readValue(inputStream, cls);
      } catch (IOException ex) {
        if (log.isErrorEnabled()) {
          log.error("Exception thrown while loading {}", resourcePath, ex);
        }
        throw ex;
      }

      if (null != relativePath.getParent()) {
        data.path(relativePath);
      } else {
        data.path(relativePath);
      }
      datas.add(data);
    }
    return datas;
  }

public List<RuleFactory> findFactories(List<String> packages) {
    List<RuleFactory> resultL = new ArrayList<>();
    FilterBuilder fb = new FilterBuilder();
    for(String packageName: packages) {
            fb.include(FilterBuilder.prefix(packageName));
    }
    try {
        doPackage(fb, resultL);
    } catch (Exception e) {
        e.printStackTrace();
    }
    return resultL;
}

private CamelCatalog createCamelCatalog() throws IOException{
    CamelCatalog result = new DefaultCamelCatalog(true);
    //add funktion camel components

    Predicate<String> filter = new FilterBuilder().includePackage("io.fabric8.funktion.camel");
    Reflections resources = new Reflections(new ConfigurationBuilder()
                                                .filterInputsBy(filter)
                                                .setScanners(new ResourcesScanner())
                                                .setUrls(ClasspathHelper.forJavaClassPath()));


    Set<String> jsonFiles = resources.getResources(Pattern.compile(".*\\.json"));


    LOG.info("Processing Funktion Camel components ...");
    for (String jsonFile: jsonFiles){
        InputStream inputStream = getClass().getClassLoader().getResourceAsStream(jsonFile);
        ObjectMapper mapper = new ObjectMapper();
        JsonNode root = mapper.readTree(inputStream);
        JsonNode component = root.path("component");
        if (!component.isMissingNode()) {
            String scheme = component.path("scheme").asText();
            String componentName = component.path("javaType").asText();
            result.addComponent(scheme,componentName);
            LOG.info("Processed component " + scheme);
        }else{
            LOG.error("Failed to find Component for " + jsonFile);
        }
    }
    return result;
}

@Test
public void testAllAggregateOpsAreSerializable() 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 */))
                    .setUrls(ClasspathHelper.forClassLoader(classLoadersList.toArray(new ClassLoader[0])))
                    .filterInputsBy(new FilterBuilder()
                                    .include(FilterBuilder.prefix("org.datavec.api.transform.ops"))));

    Set<String> allTypes = reflections.getAllTypes();
    Set<String> ops = new HashSet<>();

    for (String type : allTypes) {
        if (type.startsWith("org.datavec.api.transform.ops")) {
            if (type.endsWith("Op")) {
                ops.add(type);
            }

            if (type.contains("Aggregable") && !type.endsWith("Test")) {
                ops.add(type);
            }
        }
    }

    for (String op : ops) {
        Class<?> cls = Class.forName(op);
        assertTrue(op + " should implement Serializable", implementsSerializable(cls));
    }
}

public CommandManager() {
    ConfigurationBuilder builder = new ConfigurationBuilder()
            .setScanners(new SubTypesScanner(false), new ResourcesScanner())
            .setUrls(ClasspathHelper.forClassLoader(Arrays.asList(ClasspathHelper.contextClassLoader(), ClasspathHelper.staticClassLoader()).toArray(new ClassLoader[0])))
            .filterInputsBy(new FilterBuilder().include(FilterBuilder.prefix("github.scarsz.discordsrv.commands")));
    builder = builder.setUrls(builder.getUrls().stream().filter(url -> !Pattern.compile(".*[.](so|dll)", Pattern.CASE_INSENSITIVE).matcher(url.getFile()).matches()).collect(Collectors.toList()));
    Reflections reflections = new Reflections(builder);

    for (String className : reflections.getAllTypes()) {
        Class clazz; try { clazz = Class.forName(className); } catch (ClassNotFoundException ignored) { continue; }

        if (clazz.isAnnotation()) continue;

        for (Method method : clazz.getMethods()) {
            if (!method.isAnnotationPresent(Command.class)) continue; // make sure method is marked as an annotation

            if (method.getParameters().length != 2) {
                DiscordSRV.debug("Method " + method.toGenericString().replace("public static void ", "") + " annotated as command but parameters count != 2");
                continue;
            }
            if (method.getParameters()[0].getType() != CommandSender.class && method.getParameters()[0].getType() != Player.class) {
                DiscordSRV.debug("Method " + method.toGenericString().replace("public static void ", "") + " annotated as command but parameter 1's type != CommandSender || Player");
                continue;
            }
            if (method.getParameters()[1].getType() != String[].class) {
                DiscordSRV.debug("Method " + method.toGenericString().replace("public static void ", "") + " annotated as command but parameter 2's type != String[]");
                continue;
            }

            Command annotation = method.getAnnotation(Command.class);
            for (String commandName : annotation.commandNames()) commands.put(commandName.toLowerCase(), method);
        }
    }
}